from decimal import Decimal
from enum import Enum
from typing import Optional, Union

from pydantic import BaseModel, ConfigDict
from xsdata.models.datatype import XmlDate, XmlDateTime, XmlTime
from xsdata_pydantic.fields import field

__NAMESPACE__ = "http://www.opentravel.org/OTA/2003/05"


class BaseByGuestAmtType(Enum):
    VALUE_7 = "7"
    VALUE_25 = "25"


class BookingRuleCodeContext(Enum):
    ROOMTYPE = "ROOMTYPE"


class CommentName1(Enum):
    TITLE = "Title"
    CATEGORY = "Category"
    GALLERY = "Gallery"
    DESCRIPTION = "Description"


class CommentName2(Enum):
    INCLUDED_SERVICES = "included services"
    CUSTOMER_COMMENT = "customer comment"
    ADDITIONAL_INFO = "additional info"


class ContactInfoLocation(Enum):
    VALUE_6 = "6"


class DescriptionName(Enum):
    TITLE = "title"
    INTRO = "intro"
    DESCRIPTION = "description"
    GALLERY = "gallery"
    CODELIST = "codelist"


class DescriptionTextFormat1(Enum):
    PLAIN_TEXT = "PlainText"
    HTML = "HTML"


class DescriptionTextFormat2(Enum):
    PLAIN_TEXT = "PlainText"


class DiscountPercent(Enum):
    VALUE_100 = "100"


class ErrorStatus(Enum):
    ALPINEBITS_HANDSHAKE = "ALPINEBITS_HANDSHAKE"


class ErrorType(Enum):
    VALUE_11 = "11"
    VALUE_13 = "13"


class EventIdType(Enum):
    VALUE_18 = "18"


class GuestFirstQualifyingPosition(Enum):
    VALUE_1 = "1"


class HotelReservationResStatus(Enum):
    REQUESTED = "Requested"
    RESERVED = "Reserved"
    CANCELLED = "Cancelled"
    MODIFY = "Modify"


class ImageItemCategory(Enum):
    VALUE_1 = "1"
    VALUE_2 = "2"
    VALUE_4 = "4"
    VALUE_12 = "12"
    VALUE_15 = "15"
    VALUE_22 = "22"


class InvCountCountType(Enum):
    VALUE_2 = "2"
    VALUE_6 = "6"
    VALUE_9 = "9"


class LengthOfStayMinMaxMessageType1(Enum):
    SET_MIN_LOS = "SetMinLOS"
    SET_FORWARD_MIN_STAY = "SetForwardMinStay"
    SET_MAX_LOS = "SetMaxLOS"
    SET_FORWARD_MAX_STAY = "SetForwardMaxStay"


class LengthOfStayMinMaxMessageType2(Enum):
    SET_MIN_LOS = "SetMinLOS"
    SET_MAX_LOS = "SetMaxLOS"
    VALUE = ""


class LengthOfStayTimeUnit(Enum):
    DAY = "Day"


class MealsIncludedMealPlanCodes(Enum):
    VALUE_1 = "1"
    VALUE_3 = "3"
    VALUE_10 = "10"
    VALUE_12 = "12"
    VALUE_14 = "14"


class MealsIncludedMealPlanIndicator(Enum):
    VALUE_1 = "1"
    TRUE = "true"


class MultimediaDescriptionInfoCode1(Enum):
    VALUE_1 = "1"
    VALUE_17 = "17"
    VALUE_23 = "23"
    VALUE_24 = "24"


class MultimediaDescriptionInfoCode2(Enum):
    VALUE_1 = "1"
    VALUE_23 = "23"
    VALUE_25 = "25"


class OtaHotelDescriptiveInfoRq(BaseModel):
    class Meta:
        name = "OTA_HotelDescriptiveInfoRQ"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    hotel_descriptive_infos: "OtaHotelDescriptiveInfoRq.HotelDescriptiveInfos" = field(
        metadata={
            "name": "HotelDescriptiveInfos",
            "type": "Element",
            "required": True,
        }
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class HotelDescriptiveInfos(BaseModel):
        model_config = ConfigDict(defer_build=True)
        hotel_descriptive_info: "OtaHotelDescriptiveInfoRq.HotelDescriptiveInfos.HotelDescriptiveInfo" = field(
            metadata={
                "name": "HotelDescriptiveInfo",
                "type": "Element",
                "required": True,
            }
        )

        class HotelDescriptiveInfo(BaseModel):
            model_config = ConfigDict(defer_build=True)
            hotel_code: str = field(
                metadata={
                    "name": "HotelCode",
                    "type": "Attribute",
                    "required": True,
                    "min_length": 1,
                    "max_length": 16,
                }
            )
            hotel_name: Optional[str] = field(
                default=None,
                metadata={
                    "name": "HotelName",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 128,
                },
            )


class OtaHotelRatePlanRq(BaseModel):
    class Meta:
        name = "OTA_HotelRatePlanRQ"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    rate_plans: "OtaHotelRatePlanRq.RatePlans" = field(
        metadata={
            "name": "RatePlans",
            "type": "Element",
            "required": True,
        }
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class RatePlans(BaseModel):
        model_config = ConfigDict(defer_build=True)
        rate_plan: "OtaHotelRatePlanRq.RatePlans.RatePlan" = field(
            metadata={
                "name": "RatePlan",
                "type": "Element",
                "required": True,
            }
        )

        class RatePlan(BaseModel):
            model_config = ConfigDict(defer_build=True)
            date_range: list["OtaHotelRatePlanRq.RatePlans.RatePlan.DateRange"] = field(
                default_factory=list,
                metadata={
                    "name": "DateRange",
                    "type": "Element",
                },
            )
            rate_plan_candidates: list[
                "OtaHotelRatePlanRq.RatePlans.RatePlan.RatePlanCandidates"
            ] = field(
                default_factory=list,
                metadata={
                    "name": "RatePlanCandidates",
                    "type": "Element",
                },
            )
            hotel_ref: list["OtaHotelRatePlanRq.RatePlans.RatePlan.HotelRef"] = field(
                default_factory=list,
                metadata={
                    "name": "HotelRef",
                    "type": "Element",
                },
            )

            class DateRange(BaseModel):
                model_config = ConfigDict(defer_build=True)
                start: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "Start",
                        "type": "Attribute",
                        "pattern": r"\S+",
                    },
                )
                end: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "End",
                        "type": "Attribute",
                        "pattern": r"\S+",
                    },
                )

            class RatePlanCandidates(BaseModel):
                model_config = ConfigDict(defer_build=True)
                rate_plan_candidate: list[
                    "OtaHotelRatePlanRq.RatePlans.RatePlan.RatePlanCandidates.RatePlanCandidate"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "RatePlanCandidate",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class RatePlanCandidate(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    rate_plan_code: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "RatePlanCode",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 64,
                        },
                    )
                    rate_plan_id: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "RatePlanID",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 64,
                        },
                    )

            class HotelRef(BaseModel):
                model_config = ConfigDict(defer_build=True)
                hotel_code: str = field(
                    metadata={
                        "name": "HotelCode",
                        "type": "Attribute",
                        "required": True,
                        "min_length": 1,
                        "max_length": 16,
                    }
                )
                hotel_name: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "HotelName",
                        "type": "Attribute",
                        "min_length": 1,
                        "max_length": 128,
                    },
                )


class OtaPingRq(BaseModel):
    class Meta:
        name = "OTA_PingRQ"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    echo_data: str = field(
        metadata={
            "name": "EchoData",
            "type": "Element",
            "required": True,
            "min_length": 1,
        }
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )


class OtaReadRq(BaseModel):
    class Meta:
        name = "OTA_ReadRQ"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    read_requests: "OtaReadRq.ReadRequests" = field(
        metadata={
            "name": "ReadRequests",
            "type": "Element",
            "required": True,
        }
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class ReadRequests(BaseModel):
        model_config = ConfigDict(defer_build=True)
        hotel_read_request: "OtaReadRq.ReadRequests.HotelReadRequest" = field(
            metadata={
                "name": "HotelReadRequest",
                "type": "Element",
                "required": True,
            }
        )

        class HotelReadRequest(BaseModel):
            model_config = ConfigDict(defer_build=True)
            selection_criteria: Optional[
                "OtaReadRq.ReadRequests.HotelReadRequest.SelectionCriteria"
            ] = field(
                default=None,
                metadata={
                    "name": "SelectionCriteria",
                    "type": "Element",
                },
            )
            hotel_code: str = field(
                metadata={
                    "name": "HotelCode",
                    "type": "Attribute",
                    "required": True,
                    "min_length": 1,
                    "max_length": 16,
                }
            )
            hotel_name: Optional[str] = field(
                default=None,
                metadata={
                    "name": "HotelName",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 128,
                },
            )

            class SelectionCriteria(BaseModel):
                model_config = ConfigDict(defer_build=True)
                start: str = field(
                    metadata={
                        "name": "Start",
                        "type": "Attribute",
                        "required": True,
                        "pattern": r"\S+",
                    }
                )


class OccupancyAgeQualifyingCode(Enum):
    VALUE_8 = "8"
    VALUE_10 = "10"


class PositionAltitudeUnitOfMeasureCode(Enum):
    VALUE_3 = "3"


class PrerequisiteInventoryInvType(Enum):
    ALPINEBITSDOW = "ALPINEBITSDOW"
    ROOMTYPE = "ROOMTYPE"


class ProfileProfileType(Enum):
    VALUE_4 = "4"


class RateDescriptionName(Enum):
    INCLUDED_SERVICES = "included services"


class RatePlanRatePlanNotifType(Enum):
    OVERLAY = "Overlay"
    NEW = "New"
    FULL = "Full"
    REMOVE = "Remove"


class RatePlanRatePlanType(Enum):
    VALUE_12 = "12"


class RateRateTimeUnit(Enum):
    DAY = "Day"


class RestrictionStatusRestriction(Enum):
    MASTER = "Master"


class RestrictionStatusStatus(Enum):
    OPEN = "Open"
    CLOSE = "Close"


class RoomTypeRoomType(Enum):
    VALUE_1 = "1"
    VALUE_2 = "2"
    VALUE_3 = "3"
    VALUE_4 = "4"
    VALUE_5 = "5"
    VALUE_6 = "6"
    VALUE_7 = "7"
    VALUE_8 = "8"
    VALUE_9 = "9"


class ServiceMealPlanCode(Enum):
    VALUE_12 = "12"


class ServiceServiceCategoryCode(Enum):
    BOARD = "BOARD"
    SUPPLEMENT = "SUPPLEMENT"
    SPA = "SPA"
    FOOD = "FOOD"
    BEVERAGE = "BEVERAGE"
    ACTIVITY = "ACTIVITY"
    TOURISTTAX = "TOURISTTAX"
    TRANSFER = "TRANSFER"
    OTHER = "OTHER"


class ServiceServicePricingType(Enum):
    PER_NIGHT = "Per night"
    PER_PERSON = "Per person"
    PER_PERSON_PER_NIGHT = "Per person per night"
    PER_STAY = "Per stay"
    PER_USE = "Per use"


class ServiceType(Enum):
    VALUE_16 = "16"


class SpecialRequestCodeContext(Enum):
    ALPINEBITS = "ALPINEBITS"
    HOTEL = "HOTEL"


class StayRequirementStayContext(Enum):
    CHECKIN = "Checkin"
    CHECKOUT = "Checkout"


class SupplementAddToBasicRateIndicator(Enum):
    VALUE_1 = "1"
    TRUE = "true"


class SupplementChargeTypeCode(Enum):
    VALUE_1 = "1"
    VALUE_12 = "12"
    VALUE_18 = "18"
    VALUE_19 = "19"
    VALUE_20 = "20"
    VALUE_21 = "21"
    VALUE_24 = "24"


class SupplementInvType(Enum):
    EXTRA = "EXTRA"
    ALPINEBITSEXTRA = "ALPINEBITSEXTRA"


class TaxPolicyChargeFrequency(Enum):
    VALUE_1 = "1"


class TaxPolicyChargeUnit(Enum):
    VALUE_21 = "21"


class TaxPolicyCode(Enum):
    VALUE_3 = "3"


class TextTextFormat1(Enum):
    PLAIN_TEXT = "PlainText"


class TextTextFormat2(Enum):
    PLAIN_TEXT = "PlainText"
    HTML = "HTML"


class TimeUnitType(Enum):
    """
    Defines the unit in which the time is expressed (e.g. year, day, hour).
    """

    YEAR = "Year"
    MONTH = "Month"
    WEEK = "Week"
    DAY = "Day"
    HOUR = "Hour"
    SECOND = "Second"
    FULL_DURATION = "FullDuration"
    MINUTE = "Minute"


class TypeRoomRoomType(Enum):
    VALUE_1 = "1"
    VALUE_2 = "2"
    VALUE_3 = "3"
    VALUE_4 = "4"
    VALUE_5 = "5"
    VALUE_6 = "6"
    VALUE_7 = "7"
    VALUE_8 = "8"
    VALUE_9 = "9"


class UrlType(Enum):
    IMAGE = "Image"


class UniqueIdInstance(Enum):
    COMPLETE_SET = "CompleteSet"


class UniqueIdType1(Enum):
    VALUE_16 = "16"
    VALUE_35 = "35"


class UniqueIdType2(Enum):
    VALUE_14 = "14"
    VALUE_15 = "15"


class UniqueIdType3(Enum):
    VALUE_16 = "16"


class VideoItemCategory(Enum):
    VALUE_1 = "1"
    VALUE_2 = "2"
    VALUE_4 = "4"
    VALUE_12 = "12"
    VALUE_20 = "20"
    VALUE_22 = "22"


class WarningStatus(Enum):
    ALPINEBITS_HANDSHAKE = "ALPINEBITS_HANDSHAKE"


class DefSendComplete(Enum):
    ALPINEBITS_SEND_HANDSHAKE = "ALPINEBITS_SEND_HANDSHAKE"
    ALPINEBITS_SEND_FREEROOMS = "ALPINEBITS_SEND_FREEROOMS"
    ALPINEBITS_SEND_RATEPLANS = "ALPINEBITS_SEND_RATEPLANS"
    ALPINEBITS_SEND_INVENTORY = "ALPINEBITS_SEND_INVENTORY"


class OtaHotelDescriptiveContentNotifRq(BaseModel):
    class Meta:
        name = "OTA_HotelDescriptiveContentNotifRQ"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    hotel_descriptive_contents: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents" = field(
        metadata={
            "name": "HotelDescriptiveContents",
            "type": "Element",
            "required": True,
        }
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class HotelDescriptiveContents(BaseModel):
        model_config = ConfigDict(defer_build=True)
        hotel_descriptive_content: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent" = field(
            metadata={
                "name": "HotelDescriptiveContent",
                "type": "Element",
                "required": True,
            }
        )

        class HotelDescriptiveContent(BaseModel):
            model_config = ConfigDict(defer_build=True)
            hotel_info: Optional[
                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo"
            ] = field(
                default=None,
                metadata={
                    "name": "HotelInfo",
                    "type": "Element",
                },
            )
            facility_info: Optional[
                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo"
            ] = field(
                default=None,
                metadata={
                    "name": "FacilityInfo",
                    "type": "Element",
                },
            )
            policies: Optional[
                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies"
            ] = field(
                default=None,
                metadata={
                    "name": "Policies",
                    "type": "Element",
                },
            )
            affiliation_info: Optional[
                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.AffiliationInfo"
            ] = field(
                default=None,
                metadata={
                    "name": "AffiliationInfo",
                    "type": "Element",
                },
            )
            contact_infos: Optional[
                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos"
            ] = field(
                default=None,
                metadata={
                    "name": "ContactInfos",
                    "type": "Element",
                },
            )
            hotel_city_code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "HotelCityCode",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 8,
                },
            )
            hotel_code: str = field(
                metadata={
                    "name": "HotelCode",
                    "type": "Attribute",
                    "required": True,
                    "min_length": 1,
                    "max_length": 16,
                }
            )
            hotel_name: Optional[str] = field(
                default=None,
                metadata={
                    "name": "HotelName",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 128,
                },
            )
            area_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "AreaID",
                    "type": "Attribute",
                    "pattern": r"[0-9]{1,8}",
                },
            )

            class HotelInfo(BaseModel):
                model_config = ConfigDict(defer_build=True)
                category_codes: Optional[
                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.CategoryCodes"
                ] = field(
                    default=None,
                    metadata={
                        "name": "CategoryCodes",
                        "type": "Element",
                    },
                )
                descriptions: Optional[
                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Descriptions",
                        "type": "Element",
                    },
                )
                position: Optional[
                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Position"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Position",
                        "type": "Element",
                    },
                )
                services: Optional[
                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Services"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Services",
                        "type": "Element",
                    },
                )
                hotel_status_code: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "HotelStatusCode",
                        "type": "Attribute",
                        "pattern": r"[0-9]+",
                    },
                )

                class CategoryCodes(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    hotel_category: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.CategoryCodes.HotelCategory" = field(
                        metadata={
                            "name": "HotelCategory",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class HotelCategory(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        code: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Code",
                                "type": "Attribute",
                                "min_length": 1,
                            },
                        )
                        code_detail: str = field(
                            metadata={
                                "name": "CodeDetail",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 128,
                            }
                        )

                class Descriptions(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    multimedia_descriptions: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions" = field(
                        metadata={
                            "name": "MultimediaDescriptions",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class MultimediaDescriptions(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        multimedia_description: list[
                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "MultimediaDescription",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class MultimediaDescription(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            text_items: Optional[
                                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.TextItems"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "TextItems",
                                    "type": "Element",
                                },
                            )
                            image_items: Optional[
                                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.ImageItems"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "ImageItems",
                                    "type": "Element",
                                },
                            )
                            video_items: Optional[
                                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.VideoItems"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "VideoItems",
                                    "type": "Element",
                                },
                            )
                            info_code: Optional[MultimediaDescriptionInfoCode1] = field(
                                default=None,
                                metadata={
                                    "name": "InfoCode",
                                    "type": "Attribute",
                                },
                            )

                            class TextItems(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text_item: list[
                                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.TextItems.TextItem"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "TextItem",
                                        "type": "Element",
                                    },
                                )

                                class TextItem(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    description: list[
                                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.TextItems.TextItem.Description"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "Description",
                                            "type": "Element",
                                            "min_occurs": 1,
                                        },
                                    )
                                    source_id: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "SourceID",
                                            "type": "Attribute",
                                            "min_length": 1,
                                            "max_length": 32,
                                        },
                                    )
                                    copyright_notice: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "CopyrightNotice",
                                            "type": "Attribute",
                                            "min_length": 1,
                                            "max_length": 64,
                                        },
                                    )

                                    class Description(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        value: str = field(
                                            default="",
                                            metadata={
                                                "required": True,
                                                "min_length": 1,
                                            },
                                        )
                                        text_format: DescriptionTextFormat1 = field(
                                            metadata={
                                                "name": "TextFormat",
                                                "type": "Attribute",
                                                "required": True,
                                            }
                                        )
                                        language: str = field(
                                            metadata={
                                                "name": "Language",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"[a-z][a-z]",
                                            }
                                        )

                            class ImageItems(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                image_item: list[
                                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "ImageItem",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class ImageItem(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    image_format: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem.ImageFormat" = field(
                                        metadata={
                                            "name": "ImageFormat",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )
                                    description: list[
                                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem.Description"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "Description",
                                            "type": "Element",
                                        },
                                    )
                                    category: ImageItemCategory = field(
                                        metadata={
                                            "name": "Category",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )

                                    class ImageFormat(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        url: str = field(
                                            metadata={
                                                "name": "URL",
                                                "type": "Element",
                                                "required": True,
                                                "pattern": r"https?://.+",
                                            }
                                        )
                                        copyright_notice: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CopyrightNotice",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 64,
                                            },
                                        )
                                        source_id: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "SourceID",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 32,
                                            },
                                        )
                                        title: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Title",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 64,
                                            },
                                        )
                                        applicable_start: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "ApplicableStart",
                                                "type": "Attribute",
                                                "pattern": r"--[0-1][0-9]-[0-3][0-9]",
                                            },
                                        )
                                        applicable_end: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "ApplicableEnd",
                                                "type": "Attribute",
                                                "pattern": r"--[0-1][0-9]-[0-3][0-9]",
                                            },
                                        )

                                    class Description(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        value: str = field(
                                            default="",
                                            metadata={
                                                "required": True,
                                                "min_length": 1,
                                            },
                                        )
                                        text_format: DescriptionTextFormat1 = field(
                                            metadata={
                                                "name": "TextFormat",
                                                "type": "Attribute",
                                                "required": True,
                                            }
                                        )
                                        language: str = field(
                                            metadata={
                                                "name": "Language",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"[a-z][a-z]",
                                            }
                                        )

                            class VideoItems(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                video_item: list[
                                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.VideoItems.VideoItem"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "VideoItem",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class VideoItem(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    video_format: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.VideoItems.VideoItem.VideoFormat" = field(
                                        metadata={
                                            "name": "VideoFormat",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )
                                    description: list[
                                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.VideoItems.VideoItem.Description"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "Description",
                                            "type": "Element",
                                        },
                                    )
                                    category: VideoItemCategory = field(
                                        metadata={
                                            "name": "Category",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )

                                    class VideoFormat(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        url: str = field(
                                            metadata={
                                                "name": "URL",
                                                "type": "Element",
                                                "required": True,
                                                "pattern": r"https?://.+",
                                            }
                                        )
                                        copyright_notice: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CopyrightNotice",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 64,
                                            },
                                        )
                                        source_id: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "SourceID",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 32,
                                            },
                                        )
                                        title: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Title",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 64,
                                            },
                                        )
                                        applicable_start: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "ApplicableStart",
                                                "type": "Attribute",
                                                "pattern": r"[0-1][0-9]-[0-3][0-9]",
                                            },
                                        )

                                    class Description(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        value: str = field(
                                            default="",
                                            metadata={
                                                "required": True,
                                                "min_length": 1,
                                            },
                                        )
                                        text_format: DescriptionTextFormat1 = field(
                                            metadata={
                                                "name": "TextFormat",
                                                "type": "Attribute",
                                                "required": True,
                                            }
                                        )
                                        language: str = field(
                                            metadata={
                                                "name": "Language",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"[a-z][a-z]",
                                            }
                                        )

                class Position(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    altitude: Optional[Decimal] = field(
                        default=None,
                        metadata={
                            "name": "Altitude",
                            "type": "Attribute",
                        },
                    )
                    altitude_unit_of_measure_code: Optional[
                        PositionAltitudeUnitOfMeasureCode
                    ] = field(
                        default=None,
                        metadata={
                            "name": "AltitudeUnitOfMeasureCode",
                            "type": "Attribute",
                        },
                    )
                    latitude: Optional[Decimal] = field(
                        default=None,
                        metadata={
                            "name": "Latitude",
                            "type": "Attribute",
                        },
                    )
                    longitude: Optional[Decimal] = field(
                        default=None,
                        metadata={
                            "name": "Longitude",
                            "type": "Attribute",
                        },
                    )

                class Services(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    service: list[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Services.Service"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "Service",
                            "type": "Element",
                        },
                    )

                    class Service(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        features: Optional[
                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Services.Service.Features"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "Features",
                                "type": "Element",
                            },
                        )
                        code: str = field(
                            metadata={
                                "name": "Code",
                                "type": "Attribute",
                                "required": True,
                                "pattern": r"[0-9]{1,3}(\.[A-Z]{3}){0,1}",
                            }
                        )
                        meal_plan_code: Optional[ServiceMealPlanCode] = field(
                            default=None,
                            metadata={
                                "name": "MealPlanCode",
                                "type": "Attribute",
                            },
                        )
                        proximity_code: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "ProximityCode",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        included: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Included",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )

                        class Features(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            feature: list[
                                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Services.Service.Features.Feature"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "Feature",
                                    "type": "Element",
                                },
                            )

                            class Feature(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                accessible_code: str = field(
                                    metadata={
                                        "name": "AccessibleCode",
                                        "type": "Attribute",
                                        "required": True,
                                        "pattern": r"[0-9]+",
                                    }
                                )

            class FacilityInfo(BaseModel):
                model_config = ConfigDict(defer_build=True)
                guest_rooms: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms" = field(
                    metadata={
                        "name": "GuestRooms",
                        "type": "Element",
                        "required": True,
                    }
                )

                class GuestRooms(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    guest_room: list[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "GuestRoom",
                            "type": "Element",
                        },
                    )

                    class GuestRoom(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        type_room: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.TypeRoom" = field(
                            metadata={
                                "name": "TypeRoom",
                                "type": "Element",
                                "required": True,
                            }
                        )
                        amenities: Optional[
                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.Amenities"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "Amenities",
                                "type": "Element",
                            },
                        )
                        multimedia_descriptions: Optional[
                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "MultimediaDescriptions",
                                "type": "Element",
                            },
                        )
                        code: str = field(
                            metadata={
                                "name": "Code",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 8,
                            }
                        )
                        max_occupancy: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "MaxOccupancy",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        min_occupancy: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "MinOccupancy",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        max_child_occupancy: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "MaxChildOccupancy",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        id: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "ID",
                                "type": "Attribute",
                                "min_length": 1,
                                "max_length": 8,
                            },
                        )

                        class TypeRoom(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            standard_occupancy: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "StandardOccupancy",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            room_classification_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "RoomClassificationCode",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            room_id: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "RoomID",
                                    "type": "Attribute",
                                    "min_length": 1,
                                    "max_length": 16,
                                },
                            )
                            size: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Size",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            room_type: Optional[TypeRoomRoomType] = field(
                                default=None,
                                metadata={
                                    "name": "RoomType",
                                    "type": "Attribute",
                                },
                            )

                        class Amenities(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            amenity: list[
                                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.Amenities.Amenity"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "Amenity",
                                    "type": "Element",
                                    "min_occurs": 1,
                                },
                            )

                            class Amenity(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                room_amenity_code: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "RoomAmenityCode",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]{1,3}(\.[A-Z]{3}){0,1}",
                                    },
                                )

                        class MultimediaDescriptions(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            multimedia_description: list[
                                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "MultimediaDescription",
                                    "type": "Element",
                                },
                            )

                            class MultimediaDescription(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text_items: Optional[
                                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.TextItems"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "TextItems",
                                        "type": "Element",
                                    },
                                )
                                image_items: Optional[
                                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.ImageItems"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "ImageItems",
                                        "type": "Element",
                                    },
                                )
                                info_code: Optional[MultimediaDescriptionInfoCode2] = (
                                    field(
                                        default=None,
                                        metadata={
                                            "name": "InfoCode",
                                            "type": "Attribute",
                                        },
                                    )
                                )

                                class TextItems(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    text_item: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.TextItems.TextItem" = field(
                                        metadata={
                                            "name": "TextItem",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )

                                    class TextItem(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        description: list[
                                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.TextItems.TextItem.Description"
                                        ] = field(
                                            default_factory=list,
                                            metadata={
                                                "name": "Description",
                                                "type": "Element",
                                                "min_occurs": 1,
                                            },
                                        )

                                        class Description(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            value: str = field(
                                                default="",
                                                metadata={
                                                    "required": True,
                                                    "min_length": 1,
                                                },
                                            )
                                            text_format: DescriptionTextFormat1 = field(
                                                metadata={
                                                    "name": "TextFormat",
                                                    "type": "Attribute",
                                                    "required": True,
                                                }
                                            )
                                            language: str = field(
                                                metadata={
                                                    "name": "Language",
                                                    "type": "Attribute",
                                                    "required": True,
                                                    "pattern": r"[a-z][a-z]",
                                                }
                                            )

                                class ImageItems(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    image_item: list[
                                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "ImageItem",
                                            "type": "Element",
                                            "min_occurs": 1,
                                        },
                                    )

                                    class ImageItem(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        image_format: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem.ImageFormat" = field(
                                            metadata={
                                                "name": "ImageFormat",
                                                "type": "Element",
                                                "required": True,
                                            }
                                        )
                                        description: list[
                                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem.Description"
                                        ] = field(
                                            default_factory=list,
                                            metadata={
                                                "name": "Description",
                                                "type": "Element",
                                            },
                                        )
                                        category: str = field(
                                            metadata={
                                                "name": "Category",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"[0-9]+",
                                            }
                                        )

                                        class ImageFormat(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            url: str = field(
                                                metadata={
                                                    "name": "URL",
                                                    "type": "Element",
                                                    "required": True,
                                                    "pattern": r"https?://.+",
                                                }
                                            )
                                            copyright_notice: Optional[str] = field(
                                                default=None,
                                                metadata={
                                                    "name": "CopyrightNotice",
                                                    "type": "Attribute",
                                                    "min_length": 1,
                                                    "max_length": 64,
                                                },
                                            )

                                        class Description(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            value: str = field(
                                                default="",
                                                metadata={
                                                    "required": True,
                                                    "min_length": 1,
                                                },
                                            )
                                            text_format: DescriptionTextFormat2 = field(
                                                metadata={
                                                    "name": "TextFormat",
                                                    "type": "Attribute",
                                                    "required": True,
                                                }
                                            )
                                            language: str = field(
                                                metadata={
                                                    "name": "Language",
                                                    "type": "Attribute",
                                                    "required": True,
                                                    "pattern": r"[a-z][a-z]",
                                                }
                                            )

            class Policies(BaseModel):
                model_config = ConfigDict(defer_build=True)
                policy: list[
                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "Policy",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class Policy(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    cancel_policy: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CancelPolicy"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "CancelPolicy",
                            "type": "Element",
                        },
                    )
                    checkout_charges: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CheckoutCharges"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "CheckoutCharges",
                            "type": "Element",
                        },
                    )
                    pets_policies: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.PetsPolicies"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "PetsPolicies",
                            "type": "Element",
                        },
                    )
                    tax_policies: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.TaxPolicies"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "TaxPolicies",
                            "type": "Element",
                        },
                    )
                    guarantee_payment_policy: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "GuaranteePaymentPolicy",
                            "type": "Element",
                        },
                    )
                    policy_info: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.PolicyInfo"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "PolicyInfo",
                            "type": "Element",
                        },
                    )
                    stay_requirements: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.StayRequirements"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "StayRequirements",
                            "type": "Element",
                        },
                    )

                    class CancelPolicy(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        cancel_penalty: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CancelPolicy.CancelPenalty" = field(
                            metadata={
                                "name": "CancelPenalty",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class CancelPenalty(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            penalty_description: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CancelPolicy.CancelPenalty.PenaltyDescription" = field(
                                metadata={
                                    "name": "PenaltyDescription",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class PenaltyDescription(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text: list[
                                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CancelPolicy.CancelPenalty.PenaltyDescription.Text"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "Text",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class Text(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    text_format: TextTextFormat2 = field(
                                        metadata={
                                            "name": "TextFormat",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                    language: str = field(
                                        metadata={
                                            "name": "Language",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[a-z][a-z]",
                                        }
                                    )

                    class CheckoutCharges(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        checkout_charge: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CheckoutCharges.CheckoutCharge" = field(
                            metadata={
                                "name": "CheckoutCharge",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class CheckoutCharge(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            description: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CheckoutCharges.CheckoutCharge.Description" = field(
                                metadata={
                                    "name": "Description",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            amount: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Amount",
                                    "type": "Attribute",
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                },
                            )
                            currency_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "min_length": 3,
                                    "max_length": 3,
                                },
                            )
                            decimal_places: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "DecimalPlaces",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )

                            class Description(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text: list[
                                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CheckoutCharges.CheckoutCharge.Description.Text"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "Text",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class Text(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    text_format: TextTextFormat2 = field(
                                        metadata={
                                            "name": "TextFormat",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                    language: str = field(
                                        metadata={
                                            "name": "Language",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[a-z][a-z]",
                                        }
                                    )

                    class PetsPolicies(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        pets_policy: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.PetsPolicies.PetsPolicy" = field(
                            metadata={
                                "name": "PetsPolicy",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class PetsPolicy(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            description: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.PetsPolicies.PetsPolicy.Description" = field(
                                metadata={
                                    "name": "Description",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            max_pet_quantity: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "MaxPetQuantity",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            non_refundable_fee: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "NonRefundableFee",
                                    "type": "Attribute",
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                },
                            )
                            charge_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "ChargeCode",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            currency_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "min_length": 3,
                                    "max_length": 3,
                                },
                            )
                            decimal_places: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "DecimalPlaces",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )

                            class Description(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text: list[
                                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.PetsPolicies.PetsPolicy.Description.Text"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "Text",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class Text(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    text_format: TextTextFormat2 = field(
                                        metadata={
                                            "name": "TextFormat",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                    language: str = field(
                                        metadata={
                                            "name": "Language",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[a-z][a-z]",
                                        }
                                    )

                    class TaxPolicies(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        tax_policy: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.TaxPolicies.TaxPolicy" = field(
                            metadata={
                                "name": "TaxPolicy",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class TaxPolicy(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            tax_description: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.TaxPolicies.TaxPolicy.TaxDescription" = field(
                                metadata={
                                    "name": "TaxDescription",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            amount: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Amount",
                                    "type": "Attribute",
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                },
                            )
                            currency_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "min_length": 3,
                                    "max_length": 3,
                                },
                            )
                            decimal_places: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "DecimalPlaces",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            code: Optional[TaxPolicyCode] = field(
                                default=None,
                                metadata={
                                    "name": "Code",
                                    "type": "Attribute",
                                },
                            )
                            charge_frequency: Optional[TaxPolicyChargeFrequency] = (
                                field(
                                    default=None,
                                    metadata={
                                        "name": "ChargeFrequency",
                                        "type": "Attribute",
                                    },
                                )
                            )
                            charge_unit: Optional[TaxPolicyChargeUnit] = field(
                                default=None,
                                metadata={
                                    "name": "ChargeUnit",
                                    "type": "Attribute",
                                },
                            )

                            class TaxDescription(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text: list[
                                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.TaxPolicies.TaxPolicy.TaxDescription.Text"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "Text",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class Text(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    text_format: TextTextFormat2 = field(
                                        metadata={
                                            "name": "TextFormat",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                    language: str = field(
                                        metadata={
                                            "name": "Language",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[a-z][a-z]",
                                        }
                                    )

                    class GuaranteePaymentPolicy(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        guarantee_payment: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment" = field(
                            metadata={
                                "name": "GuaranteePayment",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class GuaranteePayment(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            accepted_payments: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments" = field(
                                metadata={
                                    "name": "AcceptedPayments",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            amount_percent: Optional[
                                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AmountPercent"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "AmountPercent",
                                    "type": "Element",
                                },
                            )
                            deadline: Optional[
                                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.Deadline"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "Deadline",
                                    "type": "Element",
                                },
                            )

                            class AcceptedPayments(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                accepted_payment: list[
                                    "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "AcceptedPayment",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class AcceptedPayment(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    bank_acct: Optional[
                                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment.BankAcct"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "BankAcct",
                                            "type": "Element",
                                        },
                                    )
                                    cash: Optional[
                                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment.Cash"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "Cash",
                                            "type": "Element",
                                        },
                                    )
                                    payment_card: Optional[
                                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment.PaymentCard"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "PaymentCard",
                                            "type": "Element",
                                        },
                                    )

                                    class BankAcct(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        bank_acct_name: str = field(
                                            metadata={
                                                "name": "BankAcctName",
                                                "type": "Element",
                                                "required": True,
                                                "min_length": 1,
                                                "max_length": 64,
                                            }
                                        )
                                        bank_acct_number: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment.BankAcct.BankAcctNumber" = field(
                                            metadata={
                                                "name": "BankAcctNumber",
                                                "type": "Element",
                                                "required": True,
                                            }
                                        )
                                        bank_id: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment.BankAcct.BankId" = field(
                                            metadata={
                                                "name": "BankID",
                                                "type": "Element",
                                                "required": True,
                                            }
                                        )

                                        class BankAcctNumber(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            plain_text: str = field(
                                                metadata={
                                                    "name": "PlainText",
                                                    "type": "Element",
                                                    "required": True,
                                                    "pattern": r"[0-9]{1,19}",
                                                }
                                            )

                                        class BankId(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            plain_text: str = field(
                                                metadata={
                                                    "name": "PlainText",
                                                    "type": "Element",
                                                    "required": True,
                                                    "pattern": r"[0-9]{1,19}",
                                                }
                                            )

                                    class Cash(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        cash_indicator: str = field(
                                            metadata={
                                                "name": "CashIndicator",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"\S+",
                                            }
                                        )

                                    class PaymentCard(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        card_type: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CardType",
                                                "type": "Element",
                                                "min_length": 1,
                                            },
                                        )
                                        card_code: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CardCode",
                                                "type": "Attribute",
                                                "min_length": 1,
                                            },
                                        )

                            class AmountPercent(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                percent: str = field(
                                    metadata={
                                        "name": "Percent",
                                        "type": "Attribute",
                                        "required": True,
                                        "min_exclusive": "0.0",
                                        "pattern": r"[0-9]*\.?[0-9]*",
                                    }
                                )

                            class Deadline(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                offset_drop_time: str = field(
                                    metadata={
                                        "name": "OffsetDropTime",
                                        "type": "Attribute",
                                        "required": True,
                                        "min_length": 1,
                                    }
                                )
                                offset_time_unit: TimeUnitType = field(
                                    metadata={
                                        "name": "OffsetTimeUnit",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )
                                offset_unit_multiplier: str = field(
                                    metadata={
                                        "name": "OffsetUnitMultiplier",
                                        "type": "Attribute",
                                        "required": True,
                                        "pattern": r"[0-9]+",
                                    }
                                )

                    class PolicyInfo(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        min_guest_age: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "MinGuestAge",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )

                    class StayRequirements(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        stay_requirement: list[
                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.StayRequirements.StayRequirement"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "StayRequirement",
                                "type": "Element",
                                "min_occurs": 1,
                                "max_occurs": 2,
                            },
                        )

                        class StayRequirement(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            stay_context: Optional[StayRequirementStayContext] = field(
                                default=None,
                                metadata={
                                    "name": "StayContext",
                                    "type": "Attribute",
                                },
                            )
                            start: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Start",
                                    "type": "Attribute",
                                    "pattern": r"[0-2][0-9]:[0-5][0-9]:[0-5][0-9]",
                                },
                            )
                            end: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "End",
                                    "type": "Attribute",
                                    "pattern": r"[0-2][0-9]:[0-5][0-9]:[0-5][0-9]",
                                },
                            )

            class AffiliationInfo(BaseModel):
                model_config = ConfigDict(defer_build=True)
                awards: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.AffiliationInfo.Awards" = field(
                    metadata={
                        "name": "Awards",
                        "type": "Element",
                        "required": True,
                    }
                )

                class Awards(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    award: list[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.AffiliationInfo.Awards.Award"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "Award",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )

                    class Award(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        rating: str = field(
                            metadata={
                                "name": "Rating",
                                "type": "Attribute",
                                "required": True,
                                "min_inclusive": "0.0",
                                "pattern": r"[0-9]*\.?[0-9]*",
                            }
                        )
                        provider: str = field(
                            metadata={
                                "name": "Provider",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                            }
                        )
                        rating_symbol: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "RatingSymbol",
                                "type": "Attribute",
                                "min_length": 1,
                            },
                        )
                        official_appointment_ind: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "OfficialAppointmentInd",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )

            class ContactInfos(BaseModel):
                model_config = ConfigDict(defer_build=True)
                contact_info: "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo" = field(
                    metadata={
                        "name": "ContactInfo",
                        "type": "Element",
                        "required": True,
                    }
                )

                class ContactInfo(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    addresses: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Addresses"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Addresses",
                            "type": "Element",
                        },
                    )
                    phones: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Phones"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Phones",
                            "type": "Element",
                        },
                    )
                    emails: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Emails"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Emails",
                            "type": "Element",
                        },
                    )
                    urls: Optional[
                        "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Urls"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "URLs",
                            "type": "Element",
                        },
                    )
                    company_name: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "CompanyName",
                            "type": "Element",
                            "min_length": 0,
                        },
                    )
                    location: Optional[ContactInfoLocation] = field(
                        default=None,
                        metadata={
                            "name": "Location",
                            "type": "Attribute",
                        },
                    )

                    class Addresses(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        address: list[
                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Addresses.Address"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "Address",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class Address(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            address_line: str = field(
                                metadata={
                                    "name": "AddressLine",
                                    "type": "Element",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 255,
                                }
                            )
                            city_name: str = field(
                                metadata={
                                    "name": "CityName",
                                    "type": "Element",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 64,
                                }
                            )
                            postal_code: str = field(
                                metadata={
                                    "name": "PostalCode",
                                    "type": "Element",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 16,
                                }
                            )
                            state_prov: Optional[
                                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Addresses.Address.StateProv"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "StateProv",
                                    "type": "Element",
                                },
                            )
                            country_name: Optional[
                                "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Addresses.Address.CountryName"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "CountryName",
                                    "type": "Element",
                                },
                            )
                            language: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Language",
                                    "type": "Attribute",
                                    "pattern": r"[a-z][a-z]",
                                },
                            )

                            class StateProv(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                state_code: str = field(
                                    metadata={
                                        "name": "StateCode",
                                        "type": "Attribute",
                                        "required": True,
                                        "min_length": 1,
                                    }
                                )

                            class CountryName(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                code: str = field(
                                    metadata={
                                        "name": "Code",
                                        "type": "Attribute",
                                        "required": True,
                                        "pattern": r"[A-Z][A-Z]",
                                    }
                                )

                    class Phones(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        phone: list[
                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Phones.Phone"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "Phone",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class Phone(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            phone_tech_type: str = field(
                                metadata={
                                    "name": "PhoneTechType",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_length": 1,
                                }
                            )
                            phone_number: str = field(
                                metadata={
                                    "name": "PhoneNumber",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"\+?[0-9]+",
                                }
                            )

                    class Emails(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        email: list[
                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Emails.Email"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "Email",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class Email(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                    "min_length": 1,
                                },
                            )
                            email_type: str = field(
                                metadata={
                                    "name": "EmailType",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_length": 1,
                                }
                            )

                    class Urls(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        url: list[
                            "OtaHotelDescriptiveContentNotifRq.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Urls.Url"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "URL",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class Url(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                },
                            )
                            id: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "ID",
                                    "type": "Attribute",
                                    "pattern": r"[A-Z]+",
                                },
                            )


class OtaHotelDescriptiveContentNotifRs(BaseModel):
    class Meta:
        name = "OTA_HotelDescriptiveContentNotifRS"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    errors: Optional["OtaHotelDescriptiveContentNotifRs.Errors"] = field(
        default=None,
        metadata={
            "name": "Errors",
            "type": "Element",
        },
    )
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaHotelDescriptiveContentNotifRs.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Errors(BaseModel):
        model_config = ConfigDict(defer_build=True)
        error: list["OtaHotelDescriptiveContentNotifRs.Errors.Error"] = field(
            default_factory=list,
            metadata={
                "name": "Error",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Error(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: ErrorType = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaHotelDescriptiveContentNotifRs.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            record_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RecordID",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )


class OtaHotelDescriptiveInfoRs(BaseModel):
    class Meta:
        name = "OTA_HotelDescriptiveInfoRS"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    errors: Optional["OtaHotelDescriptiveInfoRs.Errors"] = field(
        default=None,
        metadata={
            "name": "Errors",
            "type": "Element",
        },
    )
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaHotelDescriptiveInfoRs.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    hotel_descriptive_contents: Optional[
        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents"
    ] = field(
        default=None,
        metadata={
            "name": "HotelDescriptiveContents",
            "type": "Element",
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Errors(BaseModel):
        model_config = ConfigDict(defer_build=True)
        error: list["OtaHotelDescriptiveInfoRs.Errors.Error"] = field(
            default_factory=list,
            metadata={
                "name": "Error",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Error(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: ErrorType = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaHotelDescriptiveInfoRs.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            record_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RecordID",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class HotelDescriptiveContents(BaseModel):
        model_config = ConfigDict(defer_build=True)
        hotel_descriptive_content: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent" = field(
            metadata={
                "name": "HotelDescriptiveContent",
                "type": "Element",
                "required": True,
            }
        )

        class HotelDescriptiveContent(BaseModel):
            model_config = ConfigDict(defer_build=True)
            hotel_info: Optional[
                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo"
            ] = field(
                default=None,
                metadata={
                    "name": "HotelInfo",
                    "type": "Element",
                },
            )
            facility_info: Optional[
                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo"
            ] = field(
                default=None,
                metadata={
                    "name": "FacilityInfo",
                    "type": "Element",
                },
            )
            policies: Optional[
                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies"
            ] = field(
                default=None,
                metadata={
                    "name": "Policies",
                    "type": "Element",
                },
            )
            affiliation_info: Optional[
                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.AffiliationInfo"
            ] = field(
                default=None,
                metadata={
                    "name": "AffiliationInfo",
                    "type": "Element",
                },
            )
            contact_infos: Optional[
                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos"
            ] = field(
                default=None,
                metadata={
                    "name": "ContactInfos",
                    "type": "Element",
                },
            )
            hotel_city_code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "HotelCityCode",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 8,
                },
            )
            hotel_code: str = field(
                metadata={
                    "name": "HotelCode",
                    "type": "Attribute",
                    "required": True,
                    "min_length": 1,
                    "max_length": 16,
                }
            )
            hotel_name: Optional[str] = field(
                default=None,
                metadata={
                    "name": "HotelName",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 128,
                },
            )
            area_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "AreaID",
                    "type": "Attribute",
                    "pattern": r"[0-9]{1,8}",
                },
            )

            class HotelInfo(BaseModel):
                model_config = ConfigDict(defer_build=True)
                category_codes: Optional[
                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.CategoryCodes"
                ] = field(
                    default=None,
                    metadata={
                        "name": "CategoryCodes",
                        "type": "Element",
                    },
                )
                descriptions: Optional[
                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Descriptions",
                        "type": "Element",
                    },
                )
                position: Optional[
                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Position"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Position",
                        "type": "Element",
                    },
                )
                services: Optional[
                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Services"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Services",
                        "type": "Element",
                    },
                )
                hotel_status_code: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "HotelStatusCode",
                        "type": "Attribute",
                        "pattern": r"[0-9]+",
                    },
                )

                class CategoryCodes(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    hotel_category: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.CategoryCodes.HotelCategory" = field(
                        metadata={
                            "name": "HotelCategory",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class HotelCategory(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        code: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Code",
                                "type": "Attribute",
                                "min_length": 1,
                            },
                        )
                        code_detail: str = field(
                            metadata={
                                "name": "CodeDetail",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 128,
                            }
                        )

                class Descriptions(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    multimedia_descriptions: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions" = field(
                        metadata={
                            "name": "MultimediaDescriptions",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class MultimediaDescriptions(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        multimedia_description: list[
                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "MultimediaDescription",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class MultimediaDescription(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            text_items: Optional[
                                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.TextItems"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "TextItems",
                                    "type": "Element",
                                },
                            )
                            image_items: Optional[
                                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.ImageItems"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "ImageItems",
                                    "type": "Element",
                                },
                            )
                            video_items: Optional[
                                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.VideoItems"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "VideoItems",
                                    "type": "Element",
                                },
                            )
                            info_code: Optional[MultimediaDescriptionInfoCode1] = field(
                                default=None,
                                metadata={
                                    "name": "InfoCode",
                                    "type": "Attribute",
                                },
                            )

                            class TextItems(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text_item: list[
                                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.TextItems.TextItem"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "TextItem",
                                        "type": "Element",
                                    },
                                )

                                class TextItem(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    description: list[
                                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.TextItems.TextItem.Description"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "Description",
                                            "type": "Element",
                                            "min_occurs": 1,
                                        },
                                    )
                                    source_id: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "SourceID",
                                            "type": "Attribute",
                                            "min_length": 1,
                                            "max_length": 32,
                                        },
                                    )
                                    copyright_notice: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "CopyrightNotice",
                                            "type": "Attribute",
                                            "min_length": 1,
                                            "max_length": 64,
                                        },
                                    )

                                    class Description(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        value: str = field(
                                            default="",
                                            metadata={
                                                "required": True,
                                                "min_length": 1,
                                            },
                                        )
                                        text_format: DescriptionTextFormat1 = field(
                                            metadata={
                                                "name": "TextFormat",
                                                "type": "Attribute",
                                                "required": True,
                                            }
                                        )
                                        language: str = field(
                                            metadata={
                                                "name": "Language",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"[a-z][a-z]",
                                            }
                                        )

                            class ImageItems(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                image_item: list[
                                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "ImageItem",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class ImageItem(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    image_format: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem.ImageFormat" = field(
                                        metadata={
                                            "name": "ImageFormat",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )
                                    description: list[
                                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem.Description"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "Description",
                                            "type": "Element",
                                        },
                                    )
                                    category: ImageItemCategory = field(
                                        metadata={
                                            "name": "Category",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )

                                    class ImageFormat(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        url: str = field(
                                            metadata={
                                                "name": "URL",
                                                "type": "Element",
                                                "required": True,
                                                "pattern": r"https?://.+",
                                            }
                                        )
                                        copyright_notice: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CopyrightNotice",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 64,
                                            },
                                        )
                                        source_id: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "SourceID",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 32,
                                            },
                                        )
                                        title: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Title",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 64,
                                            },
                                        )
                                        applicable_start: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "ApplicableStart",
                                                "type": "Attribute",
                                                "pattern": r"--[0-1][0-9]-[0-3][0-9]",
                                            },
                                        )
                                        applicable_end: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "ApplicableEnd",
                                                "type": "Attribute",
                                                "pattern": r"--[0-1][0-9]-[0-3][0-9]",
                                            },
                                        )

                                    class Description(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        value: str = field(
                                            default="",
                                            metadata={
                                                "required": True,
                                                "min_length": 1,
                                            },
                                        )
                                        text_format: DescriptionTextFormat1 = field(
                                            metadata={
                                                "name": "TextFormat",
                                                "type": "Attribute",
                                                "required": True,
                                            }
                                        )
                                        language: str = field(
                                            metadata={
                                                "name": "Language",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"[a-z][a-z]",
                                            }
                                        )

                            class VideoItems(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                video_item: list[
                                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.VideoItems.VideoItem"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "VideoItem",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class VideoItem(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    video_format: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.VideoItems.VideoItem.VideoFormat" = field(
                                        metadata={
                                            "name": "VideoFormat",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )
                                    description: list[
                                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Descriptions.MultimediaDescriptions.MultimediaDescription.VideoItems.VideoItem.Description"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "Description",
                                            "type": "Element",
                                        },
                                    )
                                    category: VideoItemCategory = field(
                                        metadata={
                                            "name": "Category",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )

                                    class VideoFormat(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        url: str = field(
                                            metadata={
                                                "name": "URL",
                                                "type": "Element",
                                                "required": True,
                                                "pattern": r"https?://.+",
                                            }
                                        )
                                        copyright_notice: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CopyrightNotice",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 64,
                                            },
                                        )
                                        source_id: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "SourceID",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 32,
                                            },
                                        )
                                        title: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Title",
                                                "type": "Attribute",
                                                "min_length": 1,
                                                "max_length": 64,
                                            },
                                        )
                                        applicable_start: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "ApplicableStart",
                                                "type": "Attribute",
                                                "pattern": r"[0-1][0-9]-[0-3][0-9]",
                                            },
                                        )

                                    class Description(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        value: str = field(
                                            default="",
                                            metadata={
                                                "required": True,
                                                "min_length": 1,
                                            },
                                        )
                                        text_format: DescriptionTextFormat1 = field(
                                            metadata={
                                                "name": "TextFormat",
                                                "type": "Attribute",
                                                "required": True,
                                            }
                                        )
                                        language: str = field(
                                            metadata={
                                                "name": "Language",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"[a-z][a-z]",
                                            }
                                        )

                class Position(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    altitude: Optional[Decimal] = field(
                        default=None,
                        metadata={
                            "name": "Altitude",
                            "type": "Attribute",
                        },
                    )
                    altitude_unit_of_measure_code: Optional[
                        PositionAltitudeUnitOfMeasureCode
                    ] = field(
                        default=None,
                        metadata={
                            "name": "AltitudeUnitOfMeasureCode",
                            "type": "Attribute",
                        },
                    )
                    latitude: Optional[Decimal] = field(
                        default=None,
                        metadata={
                            "name": "Latitude",
                            "type": "Attribute",
                        },
                    )
                    longitude: Optional[Decimal] = field(
                        default=None,
                        metadata={
                            "name": "Longitude",
                            "type": "Attribute",
                        },
                    )

                class Services(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    service: list[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Services.Service"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "Service",
                            "type": "Element",
                        },
                    )

                    class Service(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        features: Optional[
                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Services.Service.Features"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "Features",
                                "type": "Element",
                            },
                        )
                        code: str = field(
                            metadata={
                                "name": "Code",
                                "type": "Attribute",
                                "required": True,
                                "pattern": r"[0-9]{1,3}(\.[A-Z]{3}){0,1}",
                            }
                        )
                        meal_plan_code: Optional[ServiceMealPlanCode] = field(
                            default=None,
                            metadata={
                                "name": "MealPlanCode",
                                "type": "Attribute",
                            },
                        )
                        proximity_code: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "ProximityCode",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        included: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Included",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )

                        class Features(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            feature: list[
                                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.HotelInfo.Services.Service.Features.Feature"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "Feature",
                                    "type": "Element",
                                },
                            )

                            class Feature(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                accessible_code: str = field(
                                    metadata={
                                        "name": "AccessibleCode",
                                        "type": "Attribute",
                                        "required": True,
                                        "pattern": r"[0-9]+",
                                    }
                                )

            class FacilityInfo(BaseModel):
                model_config = ConfigDict(defer_build=True)
                guest_rooms: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms" = field(
                    metadata={
                        "name": "GuestRooms",
                        "type": "Element",
                        "required": True,
                    }
                )

                class GuestRooms(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    guest_room: list[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "GuestRoom",
                            "type": "Element",
                        },
                    )

                    class GuestRoom(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        type_room: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.TypeRoom" = field(
                            metadata={
                                "name": "TypeRoom",
                                "type": "Element",
                                "required": True,
                            }
                        )
                        amenities: Optional[
                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.Amenities"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "Amenities",
                                "type": "Element",
                            },
                        )
                        multimedia_descriptions: Optional[
                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "MultimediaDescriptions",
                                "type": "Element",
                            },
                        )
                        code: str = field(
                            metadata={
                                "name": "Code",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 8,
                            }
                        )
                        max_occupancy: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "MaxOccupancy",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        min_occupancy: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "MinOccupancy",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        max_child_occupancy: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "MaxChildOccupancy",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        id: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "ID",
                                "type": "Attribute",
                                "min_length": 1,
                                "max_length": 8,
                            },
                        )

                        class TypeRoom(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            standard_occupancy: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "StandardOccupancy",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            room_classification_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "RoomClassificationCode",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            room_id: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "RoomID",
                                    "type": "Attribute",
                                    "min_length": 1,
                                    "max_length": 16,
                                },
                            )
                            size: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Size",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            room_type: Optional[TypeRoomRoomType] = field(
                                default=None,
                                metadata={
                                    "name": "RoomType",
                                    "type": "Attribute",
                                },
                            )

                        class Amenities(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            amenity: list[
                                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.Amenities.Amenity"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "Amenity",
                                    "type": "Element",
                                    "min_occurs": 1,
                                },
                            )

                            class Amenity(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                room_amenity_code: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "RoomAmenityCode",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]{1,3}(\.[A-Z]{3}){0,1}",
                                    },
                                )

                        class MultimediaDescriptions(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            multimedia_description: list[
                                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "MultimediaDescription",
                                    "type": "Element",
                                },
                            )

                            class MultimediaDescription(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text_items: Optional[
                                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.TextItems"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "TextItems",
                                        "type": "Element",
                                    },
                                )
                                image_items: Optional[
                                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.ImageItems"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "ImageItems",
                                        "type": "Element",
                                    },
                                )
                                info_code: Optional[MultimediaDescriptionInfoCode2] = (
                                    field(
                                        default=None,
                                        metadata={
                                            "name": "InfoCode",
                                            "type": "Attribute",
                                        },
                                    )
                                )

                                class TextItems(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    text_item: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.TextItems.TextItem" = field(
                                        metadata={
                                            "name": "TextItem",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )

                                    class TextItem(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        description: list[
                                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.TextItems.TextItem.Description"
                                        ] = field(
                                            default_factory=list,
                                            metadata={
                                                "name": "Description",
                                                "type": "Element",
                                                "min_occurs": 1,
                                            },
                                        )

                                        class Description(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            value: str = field(
                                                default="",
                                                metadata={
                                                    "required": True,
                                                    "min_length": 1,
                                                },
                                            )
                                            text_format: DescriptionTextFormat1 = field(
                                                metadata={
                                                    "name": "TextFormat",
                                                    "type": "Attribute",
                                                    "required": True,
                                                }
                                            )
                                            language: str = field(
                                                metadata={
                                                    "name": "Language",
                                                    "type": "Attribute",
                                                    "required": True,
                                                    "pattern": r"[a-z][a-z]",
                                                }
                                            )

                                class ImageItems(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    image_item: list[
                                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "ImageItem",
                                            "type": "Element",
                                            "min_occurs": 1,
                                        },
                                    )

                                    class ImageItem(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        image_format: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem.ImageFormat" = field(
                                            metadata={
                                                "name": "ImageFormat",
                                                "type": "Element",
                                                "required": True,
                                            }
                                        )
                                        description: list[
                                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.FacilityInfo.GuestRooms.GuestRoom.MultimediaDescriptions.MultimediaDescription.ImageItems.ImageItem.Description"
                                        ] = field(
                                            default_factory=list,
                                            metadata={
                                                "name": "Description",
                                                "type": "Element",
                                            },
                                        )
                                        category: str = field(
                                            metadata={
                                                "name": "Category",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"[0-9]+",
                                            }
                                        )

                                        class ImageFormat(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            url: str = field(
                                                metadata={
                                                    "name": "URL",
                                                    "type": "Element",
                                                    "required": True,
                                                    "pattern": r"https?://.+",
                                                }
                                            )
                                            copyright_notice: Optional[str] = field(
                                                default=None,
                                                metadata={
                                                    "name": "CopyrightNotice",
                                                    "type": "Attribute",
                                                    "min_length": 1,
                                                    "max_length": 64,
                                                },
                                            )

                                        class Description(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            value: str = field(
                                                default="",
                                                metadata={
                                                    "required": True,
                                                    "min_length": 1,
                                                },
                                            )
                                            text_format: DescriptionTextFormat2 = field(
                                                metadata={
                                                    "name": "TextFormat",
                                                    "type": "Attribute",
                                                    "required": True,
                                                }
                                            )
                                            language: str = field(
                                                metadata={
                                                    "name": "Language",
                                                    "type": "Attribute",
                                                    "required": True,
                                                    "pattern": r"[a-z][a-z]",
                                                }
                                            )

            class Policies(BaseModel):
                model_config = ConfigDict(defer_build=True)
                policy: list[
                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "Policy",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class Policy(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    cancel_policy: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CancelPolicy"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "CancelPolicy",
                            "type": "Element",
                        },
                    )
                    checkout_charges: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CheckoutCharges"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "CheckoutCharges",
                            "type": "Element",
                        },
                    )
                    pets_policies: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.PetsPolicies"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "PetsPolicies",
                            "type": "Element",
                        },
                    )
                    tax_policies: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.TaxPolicies"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "TaxPolicies",
                            "type": "Element",
                        },
                    )
                    guarantee_payment_policy: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "GuaranteePaymentPolicy",
                            "type": "Element",
                        },
                    )
                    policy_info: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.PolicyInfo"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "PolicyInfo",
                            "type": "Element",
                        },
                    )
                    stay_requirements: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.StayRequirements"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "StayRequirements",
                            "type": "Element",
                        },
                    )

                    class CancelPolicy(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        cancel_penalty: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CancelPolicy.CancelPenalty" = field(
                            metadata={
                                "name": "CancelPenalty",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class CancelPenalty(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            penalty_description: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CancelPolicy.CancelPenalty.PenaltyDescription" = field(
                                metadata={
                                    "name": "PenaltyDescription",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class PenaltyDescription(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text: list[
                                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CancelPolicy.CancelPenalty.PenaltyDescription.Text"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "Text",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class Text(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    text_format: TextTextFormat2 = field(
                                        metadata={
                                            "name": "TextFormat",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                    language: str = field(
                                        metadata={
                                            "name": "Language",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[a-z][a-z]",
                                        }
                                    )

                    class CheckoutCharges(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        checkout_charge: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CheckoutCharges.CheckoutCharge" = field(
                            metadata={
                                "name": "CheckoutCharge",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class CheckoutCharge(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            description: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CheckoutCharges.CheckoutCharge.Description" = field(
                                metadata={
                                    "name": "Description",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            amount: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Amount",
                                    "type": "Attribute",
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                },
                            )
                            currency_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "min_length": 3,
                                    "max_length": 3,
                                },
                            )
                            decimal_places: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "DecimalPlaces",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )

                            class Description(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text: list[
                                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.CheckoutCharges.CheckoutCharge.Description.Text"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "Text",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class Text(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    text_format: TextTextFormat2 = field(
                                        metadata={
                                            "name": "TextFormat",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                    language: str = field(
                                        metadata={
                                            "name": "Language",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[a-z][a-z]",
                                        }
                                    )

                    class PetsPolicies(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        pets_policy: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.PetsPolicies.PetsPolicy" = field(
                            metadata={
                                "name": "PetsPolicy",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class PetsPolicy(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            description: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.PetsPolicies.PetsPolicy.Description" = field(
                                metadata={
                                    "name": "Description",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            max_pet_quantity: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "MaxPetQuantity",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            non_refundable_fee: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "NonRefundableFee",
                                    "type": "Attribute",
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                },
                            )
                            charge_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "ChargeCode",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            currency_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "min_length": 3,
                                    "max_length": 3,
                                },
                            )
                            decimal_places: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "DecimalPlaces",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )

                            class Description(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text: list[
                                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.PetsPolicies.PetsPolicy.Description.Text"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "Text",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class Text(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    text_format: TextTextFormat2 = field(
                                        metadata={
                                            "name": "TextFormat",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                    language: str = field(
                                        metadata={
                                            "name": "Language",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[a-z][a-z]",
                                        }
                                    )

                    class TaxPolicies(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        tax_policy: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.TaxPolicies.TaxPolicy" = field(
                            metadata={
                                "name": "TaxPolicy",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class TaxPolicy(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            tax_description: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.TaxPolicies.TaxPolicy.TaxDescription" = field(
                                metadata={
                                    "name": "TaxDescription",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            amount: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Amount",
                                    "type": "Attribute",
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                },
                            )
                            currency_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "min_length": 3,
                                    "max_length": 3,
                                },
                            )
                            decimal_places: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "DecimalPlaces",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            code: Optional[TaxPolicyCode] = field(
                                default=None,
                                metadata={
                                    "name": "Code",
                                    "type": "Attribute",
                                },
                            )
                            charge_frequency: Optional[TaxPolicyChargeFrequency] = (
                                field(
                                    default=None,
                                    metadata={
                                        "name": "ChargeFrequency",
                                        "type": "Attribute",
                                    },
                                )
                            )
                            charge_unit: Optional[TaxPolicyChargeUnit] = field(
                                default=None,
                                metadata={
                                    "name": "ChargeUnit",
                                    "type": "Attribute",
                                },
                            )

                            class TaxDescription(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text: list[
                                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.TaxPolicies.TaxPolicy.TaxDescription.Text"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "Text",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class Text(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    text_format: TextTextFormat2 = field(
                                        metadata={
                                            "name": "TextFormat",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                    language: str = field(
                                        metadata={
                                            "name": "Language",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[a-z][a-z]",
                                        }
                                    )

                    class GuaranteePaymentPolicy(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        guarantee_payment: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment" = field(
                            metadata={
                                "name": "GuaranteePayment",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class GuaranteePayment(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            accepted_payments: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments" = field(
                                metadata={
                                    "name": "AcceptedPayments",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            amount_percent: Optional[
                                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AmountPercent"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "AmountPercent",
                                    "type": "Element",
                                },
                            )
                            deadline: Optional[
                                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.Deadline"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "Deadline",
                                    "type": "Element",
                                },
                            )

                            class AcceptedPayments(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                accepted_payment: list[
                                    "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "AcceptedPayment",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class AcceptedPayment(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    bank_acct: Optional[
                                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment.BankAcct"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "BankAcct",
                                            "type": "Element",
                                        },
                                    )
                                    cash: Optional[
                                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment.Cash"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "Cash",
                                            "type": "Element",
                                        },
                                    )
                                    payment_card: Optional[
                                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment.PaymentCard"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "PaymentCard",
                                            "type": "Element",
                                        },
                                    )

                                    class BankAcct(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        bank_acct_name: str = field(
                                            metadata={
                                                "name": "BankAcctName",
                                                "type": "Element",
                                                "required": True,
                                                "min_length": 1,
                                                "max_length": 64,
                                            }
                                        )
                                        bank_acct_number: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment.BankAcct.BankAcctNumber" = field(
                                            metadata={
                                                "name": "BankAcctNumber",
                                                "type": "Element",
                                                "required": True,
                                            }
                                        )
                                        bank_id: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.GuaranteePaymentPolicy.GuaranteePayment.AcceptedPayments.AcceptedPayment.BankAcct.BankId" = field(
                                            metadata={
                                                "name": "BankID",
                                                "type": "Element",
                                                "required": True,
                                            }
                                        )

                                        class BankAcctNumber(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            plain_text: str = field(
                                                metadata={
                                                    "name": "PlainText",
                                                    "type": "Element",
                                                    "required": True,
                                                    "pattern": r"[0-9]{1,19}",
                                                }
                                            )

                                        class BankId(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            plain_text: str = field(
                                                metadata={
                                                    "name": "PlainText",
                                                    "type": "Element",
                                                    "required": True,
                                                    "pattern": r"[0-9]{1,19}",
                                                }
                                            )

                                    class Cash(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        cash_indicator: str = field(
                                            metadata={
                                                "name": "CashIndicator",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"\S+",
                                            }
                                        )

                                    class PaymentCard(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        card_type: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CardType",
                                                "type": "Element",
                                                "min_length": 1,
                                            },
                                        )
                                        card_code: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CardCode",
                                                "type": "Attribute",
                                                "min_length": 1,
                                            },
                                        )

                            class AmountPercent(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                percent: str = field(
                                    metadata={
                                        "name": "Percent",
                                        "type": "Attribute",
                                        "required": True,
                                        "min_exclusive": "0.0",
                                        "pattern": r"[0-9]*\.?[0-9]*",
                                    }
                                )

                            class Deadline(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                offset_drop_time: str = field(
                                    metadata={
                                        "name": "OffsetDropTime",
                                        "type": "Attribute",
                                        "required": True,
                                        "min_length": 1,
                                    }
                                )
                                offset_time_unit: TimeUnitType = field(
                                    metadata={
                                        "name": "OffsetTimeUnit",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )
                                offset_unit_multiplier: str = field(
                                    metadata={
                                        "name": "OffsetUnitMultiplier",
                                        "type": "Attribute",
                                        "required": True,
                                        "pattern": r"[0-9]+",
                                    }
                                )

                    class PolicyInfo(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        min_guest_age: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "MinGuestAge",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )

                    class StayRequirements(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        stay_requirement: list[
                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.Policies.Policy.StayRequirements.StayRequirement"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "StayRequirement",
                                "type": "Element",
                                "min_occurs": 1,
                                "max_occurs": 2,
                            },
                        )

                        class StayRequirement(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            stay_context: Optional[StayRequirementStayContext] = field(
                                default=None,
                                metadata={
                                    "name": "StayContext",
                                    "type": "Attribute",
                                },
                            )
                            start: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Start",
                                    "type": "Attribute",
                                    "pattern": r"[0-2][0-9]:[0-5][0-9]:[0-5][0-9]",
                                },
                            )
                            end: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "End",
                                    "type": "Attribute",
                                    "pattern": r"[0-2][0-9]:[0-5][0-9]:[0-5][0-9]",
                                },
                            )

            class AffiliationInfo(BaseModel):
                model_config = ConfigDict(defer_build=True)
                awards: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.AffiliationInfo.Awards" = field(
                    metadata={
                        "name": "Awards",
                        "type": "Element",
                        "required": True,
                    }
                )

                class Awards(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    award: list[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.AffiliationInfo.Awards.Award"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "Award",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )

                    class Award(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        rating: str = field(
                            metadata={
                                "name": "Rating",
                                "type": "Attribute",
                                "required": True,
                                "min_inclusive": "0.0",
                                "pattern": r"[0-9]*\.?[0-9]*",
                            }
                        )
                        provider: str = field(
                            metadata={
                                "name": "Provider",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                            }
                        )
                        rating_symbol: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "RatingSymbol",
                                "type": "Attribute",
                                "min_length": 1,
                            },
                        )
                        official_appointment_ind: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "OfficialAppointmentInd",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )

            class ContactInfos(BaseModel):
                model_config = ConfigDict(defer_build=True)
                contact_info: "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo" = field(
                    metadata={
                        "name": "ContactInfo",
                        "type": "Element",
                        "required": True,
                    }
                )

                class ContactInfo(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    addresses: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Addresses"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Addresses",
                            "type": "Element",
                        },
                    )
                    phones: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Phones"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Phones",
                            "type": "Element",
                        },
                    )
                    emails: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Emails"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Emails",
                            "type": "Element",
                        },
                    )
                    urls: Optional[
                        "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Urls"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "URLs",
                            "type": "Element",
                        },
                    )
                    company_name: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "CompanyName",
                            "type": "Element",
                            "min_length": 0,
                        },
                    )
                    location: Optional[ContactInfoLocation] = field(
                        default=None,
                        metadata={
                            "name": "Location",
                            "type": "Attribute",
                        },
                    )

                    class Addresses(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        address: list[
                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Addresses.Address"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "Address",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class Address(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            address_line: str = field(
                                metadata={
                                    "name": "AddressLine",
                                    "type": "Element",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 255,
                                }
                            )
                            city_name: str = field(
                                metadata={
                                    "name": "CityName",
                                    "type": "Element",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 64,
                                }
                            )
                            postal_code: str = field(
                                metadata={
                                    "name": "PostalCode",
                                    "type": "Element",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 16,
                                }
                            )
                            state_prov: Optional[
                                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Addresses.Address.StateProv"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "StateProv",
                                    "type": "Element",
                                },
                            )
                            country_name: Optional[
                                "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Addresses.Address.CountryName"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "CountryName",
                                    "type": "Element",
                                },
                            )
                            language: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Language",
                                    "type": "Attribute",
                                    "pattern": r"[a-z][a-z]",
                                },
                            )

                            class StateProv(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                state_code: str = field(
                                    metadata={
                                        "name": "StateCode",
                                        "type": "Attribute",
                                        "required": True,
                                        "min_length": 1,
                                    }
                                )

                            class CountryName(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                code: str = field(
                                    metadata={
                                        "name": "Code",
                                        "type": "Attribute",
                                        "required": True,
                                        "pattern": r"[A-Z][A-Z]",
                                    }
                                )

                    class Phones(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        phone: list[
                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Phones.Phone"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "Phone",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class Phone(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            phone_tech_type: str = field(
                                metadata={
                                    "name": "PhoneTechType",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_length": 1,
                                }
                            )
                            phone_number: str = field(
                                metadata={
                                    "name": "PhoneNumber",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"\+?[0-9]+",
                                }
                            )

                    class Emails(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        email: list[
                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Emails.Email"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "Email",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class Email(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                    "min_length": 1,
                                },
                            )
                            email_type: str = field(
                                metadata={
                                    "name": "EmailType",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_length": 1,
                                }
                            )

                    class Urls(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        url: list[
                            "OtaHotelDescriptiveInfoRs.HotelDescriptiveContents.HotelDescriptiveContent.ContactInfos.ContactInfo.Urls.Url"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "URL",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class Url(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                },
                            )
                            id: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "ID",
                                    "type": "Attribute",
                                    "pattern": r"[A-Z]+",
                                },
                            )


class OtaHotelInvCountNotifRq(BaseModel):
    class Meta:
        name = "OTA_HotelInvCountNotifRQ"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    unique_id: Optional["OtaHotelInvCountNotifRq.UniqueId"] = field(
        default=None,
        metadata={
            "name": "UniqueID",
            "type": "Element",
        },
    )
    inventories: "OtaHotelInvCountNotifRq.Inventories" = field(
        metadata={
            "name": "Inventories",
            "type": "Element",
            "required": True,
        }
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )

    class UniqueId(BaseModel):
        model_config = ConfigDict(defer_build=True)
        type_value: UniqueIdType1 = field(
            metadata={
                "name": "Type",
                "type": "Attribute",
                "required": True,
            }
        )
        id: str = field(
            metadata={
                "name": "ID",
                "type": "Attribute",
                "required": True,
            }
        )
        instance: UniqueIdInstance = field(
            metadata={
                "name": "Instance",
                "type": "Attribute",
                "required": True,
            }
        )

    class Inventories(BaseModel):
        model_config = ConfigDict(defer_build=True)
        inventory: list["OtaHotelInvCountNotifRq.Inventories.Inventory"] = field(
            default_factory=list,
            metadata={
                "name": "Inventory",
                "type": "Element",
                "min_occurs": 1,
            },
        )
        hotel_code: str = field(
            metadata={
                "name": "HotelCode",
                "type": "Attribute",
                "required": True,
                "min_length": 1,
                "max_length": 16,
            }
        )
        hotel_name: Optional[str] = field(
            default=None,
            metadata={
                "name": "HotelName",
                "type": "Attribute",
                "min_length": 1,
                "max_length": 128,
            },
        )

        class Inventory(BaseModel):
            model_config = ConfigDict(defer_build=True)
            status_application_control: Optional[
                "OtaHotelInvCountNotifRq.Inventories.Inventory.StatusApplicationControl"
            ] = field(
                default=None,
                metadata={
                    "name": "StatusApplicationControl",
                    "type": "Element",
                },
            )
            inv_counts: Optional[
                "OtaHotelInvCountNotifRq.Inventories.Inventory.InvCounts"
            ] = field(
                default=None,
                metadata={
                    "name": "InvCounts",
                    "type": "Element",
                },
            )

            class StatusApplicationControl(BaseModel):
                model_config = ConfigDict(defer_build=True)
                start: str = field(
                    metadata={
                        "name": "Start",
                        "type": "Attribute",
                        "required": True,
                        "pattern": r"\S+",
                    }
                )
                end: str = field(
                    metadata={
                        "name": "End",
                        "type": "Attribute",
                        "required": True,
                        "pattern": r"\S+",
                    }
                )
                inv_type_code: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "InvTypeCode",
                        "type": "Attribute",
                        "min_length": 1,
                        "max_length": 8,
                    },
                )
                inv_code: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "InvCode",
                        "type": "Attribute",
                        "min_length": 1,
                        "max_length": 16,
                    },
                )
                all_inv_code: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "AllInvCode",
                        "type": "Attribute",
                        "pattern": r"\S+",
                    },
                )

            class InvCounts(BaseModel):
                model_config = ConfigDict(defer_build=True)
                inv_count: list[
                    "OtaHotelInvCountNotifRq.Inventories.Inventory.InvCounts.InvCount"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "InvCount",
                        "type": "Element",
                        "min_occurs": 1,
                        "max_occurs": 3,
                    },
                )

                class InvCount(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    count_type: InvCountCountType = field(
                        metadata={
                            "name": "CountType",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    count: str = field(
                        metadata={
                            "name": "Count",
                            "type": "Attribute",
                            "required": True,
                            "pattern": r"[0-9]+",
                        }
                    )


class OtaHotelInvCountNotifRs(BaseModel):
    class Meta:
        name = "OTA_HotelInvCountNotifRS"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    errors: Optional["OtaHotelInvCountNotifRs.Errors"] = field(
        default=None,
        metadata={
            "name": "Errors",
            "type": "Element",
        },
    )
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaHotelInvCountNotifRs.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Errors(BaseModel):
        model_config = ConfigDict(defer_build=True)
        error: list["OtaHotelInvCountNotifRs.Errors.Error"] = field(
            default_factory=list,
            metadata={
                "name": "Error",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Error(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: ErrorType = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaHotelInvCountNotifRs.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            record_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RecordID",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )


class OtaHotelPostEventNotifRq(BaseModel):
    class Meta:
        name = "OTA_HotelPostEventNotifRQ"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    event_reports: "OtaHotelPostEventNotifRq.EventReports" = field(
        metadata={
            "name": "EventReports",
            "type": "Element",
            "required": True,
        }
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )

    class EventReports(BaseModel):
        model_config = ConfigDict(defer_build=True)
        event_report: list["OtaHotelPostEventNotifRq.EventReports.EventReport"] = field(
            default_factory=list,
            metadata={
                "name": "EventReport",
                "type": "Element",
                "min_occurs": 1,
                "max_occurs": 99,
            },
        )

        class EventReport(BaseModel):
            model_config = ConfigDict(defer_build=True)
            event_sites: "OtaHotelPostEventNotifRq.EventReports.EventReport.EventSites" = field(
                metadata={
                    "name": "EventSites",
                    "type": "Element",
                    "required": True,
                }
            )
            general_event_info: "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo" = field(
                metadata={
                    "name": "GeneralEventInfo",
                    "type": "Element",
                    "required": True,
                }
            )

            class EventSites(BaseModel):
                model_config = ConfigDict(defer_build=True)
                event_site: "OtaHotelPostEventNotifRq.EventReports.EventReport.EventSites.EventSite" = field(
                    metadata={
                        "name": "EventSite",
                        "type": "Element",
                        "required": True,
                    }
                )

                class EventSite(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    event_id: "OtaHotelPostEventNotifRq.EventReports.EventReport.EventSites.EventSite.EventId" = field(
                        metadata={
                            "name": "Event_ID",
                            "type": "Element",
                            "required": True,
                        }
                    )
                    hotel_code: str = field(
                        metadata={
                            "name": "HotelCode",
                            "type": "Attribute",
                            "required": True,
                            "min_length": 1,
                            "max_length": 16,
                        }
                    )
                    hotel_name: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "HotelName",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 128,
                        },
                    )

                    class EventId(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        id: str = field(
                            metadata={
                                "name": "ID",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 32,
                            }
                        )
                        id_context: str = field(
                            metadata={
                                "name": "ID_Context",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 32,
                            }
                        )
                        type_value: EventIdType = field(
                            metadata={
                                "name": "Type",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

            class GeneralEventInfo(BaseModel):
                model_config = ConfigDict(defer_build=True)
                event_contacts: Optional[
                    "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.EventContacts"
                ] = field(
                    default=None,
                    metadata={
                        "name": "EventContacts",
                        "type": "Element",
                    },
                )
                attendee_info: Optional[
                    "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.AttendeeInfo"
                ] = field(
                    default=None,
                    metadata={
                        "name": "AttendeeInfo",
                        "type": "Element",
                    },
                )
                dates: Optional[
                    "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.Dates"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Dates",
                        "type": "Element",
                    },
                )
                comments: Optional[
                    "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.Comments"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Comments",
                        "type": "Element",
                    },
                )
                type_value: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "Type",
                        "type": "Attribute",
                        "min_length": 1,
                    },
                )
                url: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "URL",
                        "type": "Attribute",
                        "pattern": r"https?://.+",
                    },
                )
                acronym: Optional[str] = field(
                    default=None,
                    metadata={
                        "name": "Acronym",
                        "type": "Attribute",
                        "min_length": 1,
                        "max_length": 32,
                    },
                )

                class EventContacts(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    event_contact: list[
                        "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.EventContacts.EventContact"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "EventContact",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )

                    class EventContact(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        person_name: Optional[
                            "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.EventContacts.EventContact.PersonName"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "PersonName",
                                "type": "Element",
                            },
                        )
                        url: Optional[
                            "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.EventContacts.EventContact.Url"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "URL",
                                "type": "Element",
                            },
                        )
                        employee_info: Optional[
                            "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.EventContacts.EventContact.EmployeeInfo"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "EmployeeInfo",
                                "type": "Element",
                            },
                        )
                        role: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Role",
                                "type": "Attribute",
                                "min_length": 1,
                                "max_length": 32,
                            },
                        )

                        class PersonName(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            given_name: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "GivenName",
                                    "type": "Element",
                                    "min_length": 1,
                                    "max_length": 64,
                                },
                            )
                            surname: str = field(
                                metadata={
                                    "name": "Surname",
                                    "type": "Element",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 64,
                                }
                            )

                        class Url(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                    "min_length": 1,
                                },
                            )
                            type_value: UrlType = field(
                                metadata={
                                    "name": "Type",
                                    "type": "Attribute",
                                    "required": True,
                                }
                            )

                        class EmployeeInfo(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            employee_id: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "EmployeeId",
                                    "type": "Attribute",
                                    "min_length": 1,
                                    "max_length": 16,
                                },
                            )

                class AttendeeInfo(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    total_quantity: str = field(
                        metadata={
                            "name": "TotalQuantity",
                            "type": "Attribute",
                            "required": True,
                            "pattern": r"[0-9]+",
                        }
                    )
                    pre_registered_quantity: str = field(
                        metadata={
                            "name": "PreRegisteredQuantity",
                            "type": "Attribute",
                            "required": True,
                            "pattern": r"[0-9]+",
                        }
                    )

                class Dates(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    date: list[
                        "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.Dates.Date"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "Date",
                            "type": "Element",
                            "min_occurs": 1,
                            "max_occurs": 99,
                        },
                    )

                    class Date(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        end_date_window: Optional[
                            "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.Dates.Date.EndDateWindow"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "EndDateWindow",
                                "type": "Element",
                            },
                        )
                        location_categories: Optional[
                            "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.Dates.Date.LocationCategories"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "LocationCategories",
                                "type": "Element",
                            },
                        )
                        start: Union[XmlDate, XmlDateTime, XmlTime] = field(
                            metadata={
                                "name": "Start",
                                "type": "Attribute",
                                "required": True,
                            }
                        )
                        end: Optional[Union[XmlDate, XmlDateTime, XmlTime]] = field(
                            default=None,
                            metadata={
                                "name": "End",
                                "type": "Attribute",
                            },
                        )

                        class EndDateWindow(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            latest_date: Union[XmlDate, XmlDateTime] = field(
                                metadata={
                                    "name": "LatestDate",
                                    "type": "Attribute",
                                    "required": True,
                                }
                            )

                        class LocationCategories(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            location: Optional[
                                "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.Dates.Date.LocationCategories.Location"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "Location",
                                    "type": "Element",
                                },
                            )
                            category: list[
                                "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.Dates.Date.LocationCategories.Category"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "Category",
                                    "type": "Element",
                                    "min_occurs": 1,
                                },
                            )

                            class Location(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                area_id: str = field(
                                    metadata={
                                        "name": "AreaID",
                                        "type": "Attribute",
                                        "required": True,
                                        "pattern": r"[0-9]{1,8}",
                                    }
                                )

                            class Category(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                value: str = field(
                                    default="",
                                    metadata={
                                        "required": True,
                                        "min_length": 1,
                                    },
                                )
                                language: str = field(
                                    metadata={
                                        "name": "Language",
                                        "type": "Attribute",
                                        "required": True,
                                        "pattern": r"[a-z][a-z]",
                                    }
                                )

                class Comments(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    comment: list[
                        "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.Comments.Comment"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "Comment",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )

                    class Comment(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        text: list[
                            "OtaHotelPostEventNotifRq.EventReports.EventReport.GeneralEventInfo.Comments.Comment.Text"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "Text",
                                "type": "Element",
                            },
                        )
                        image: list[str] = field(
                            default_factory=list,
                            metadata={
                                "name": "Image",
                                "type": "Element",
                                "min_length": 1,
                            },
                        )
                        name: CommentName1 = field(
                            metadata={
                                "name": "Name",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

                        class Text(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                    "min_length": 1,
                                },
                            )
                            language: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Language",
                                    "type": "Attribute",
                                    "pattern": r"[a-z][a-z]",
                                },
                            )


class OtaHotelPostEventNotifRs(BaseModel):
    class Meta:
        name = "OTA_HotelPostEventNotifRS"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    errors: Optional["OtaHotelPostEventNotifRs.Errors"] = field(
        default=None,
        metadata={
            "name": "Errors",
            "type": "Element",
        },
    )
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaHotelPostEventNotifRs.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Errors(BaseModel):
        model_config = ConfigDict(defer_build=True)
        error: list["OtaHotelPostEventNotifRs.Errors.Error"] = field(
            default_factory=list,
            metadata={
                "name": "Error",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Error(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: ErrorType = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaHotelPostEventNotifRs.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            record_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RecordID",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )


class OtaHotelRatePlanNotifRq(BaseModel):
    class Meta:
        name = "OTA_HotelRatePlanNotifRQ"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    unique_id: Optional["OtaHotelRatePlanNotifRq.UniqueId"] = field(
        default=None,
        metadata={
            "name": "UniqueID",
            "type": "Element",
        },
    )
    rate_plans: "OtaHotelRatePlanNotifRq.RatePlans" = field(
        metadata={
            "name": "RatePlans",
            "type": "Element",
            "required": True,
        }
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class UniqueId(BaseModel):
        model_config = ConfigDict(defer_build=True)
        type_value: UniqueIdType3 = field(
            metadata={
                "name": "Type",
                "type": "Attribute",
                "required": True,
            }
        )
        id: str = field(
            metadata={
                "name": "ID",
                "type": "Attribute",
                "required": True,
            }
        )
        instance: UniqueIdInstance = field(
            metadata={
                "name": "Instance",
                "type": "Attribute",
                "required": True,
            }
        )

    class RatePlans(BaseModel):
        model_config = ConfigDict(defer_build=True)
        rate_plan: list["OtaHotelRatePlanNotifRq.RatePlans.RatePlan"] = field(
            default_factory=list,
            metadata={
                "name": "RatePlan",
                "type": "Element",
                "min_occurs": 1,
            },
        )
        hotel_code: str = field(
            metadata={
                "name": "HotelCode",
                "type": "Attribute",
                "required": True,
                "min_length": 1,
                "max_length": 16,
            }
        )
        hotel_name: Optional[str] = field(
            default=None,
            metadata={
                "name": "HotelName",
                "type": "Attribute",
                "min_length": 1,
                "max_length": 128,
            },
        )

        class RatePlan(BaseModel):
            model_config = ConfigDict(defer_build=True)
            booking_rules: Optional[
                "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.BookingRules"
            ] = field(
                default=None,
                metadata={
                    "name": "BookingRules",
                    "type": "Element",
                },
            )
            rates: Optional["OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Rates"] = field(
                default=None,
                metadata={
                    "name": "Rates",
                    "type": "Element",
                },
            )
            supplements: Optional[
                "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Supplements"
            ] = field(
                default=None,
                metadata={
                    "name": "Supplements",
                    "type": "Element",
                },
            )
            offers: Optional["OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers"] = (
                field(
                    default=None,
                    metadata={
                        "name": "Offers",
                        "type": "Element",
                    },
                )
            )
            description: list[
                "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Description"
            ] = field(
                default_factory=list,
                metadata={
                    "name": "Description",
                    "type": "Element",
                    "max_occurs": 5,
                },
            )
            start: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Start",
                    "type": "Attribute",
                    "pattern": r"\S+",
                },
            )
            end: Optional[str] = field(
                default=None,
                metadata={
                    "name": "End",
                    "type": "Attribute",
                    "pattern": r"\S+",
                },
            )
            rate_plan_notif_type: Optional[RatePlanRatePlanNotifType] = field(
                default=None,
                metadata={
                    "name": "RatePlanNotifType",
                    "type": "Attribute",
                },
            )
            currency_code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "CurrencyCode",
                    "type": "Attribute",
                    "min_length": 3,
                    "max_length": 3,
                },
            )
            rate_plan_code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RatePlanCode",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            rate_plan_type: Optional[RatePlanRatePlanType] = field(
                default=None,
                metadata={
                    "name": "RatePlanType",
                    "type": "Attribute",
                },
            )
            rate_plan_category: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RatePlanCategory",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            rate_plan_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RatePlanID",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            rate_plan_qualifier: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RatePlanQualifier",
                    "type": "Attribute",
                    "pattern": r"\S+",
                },
            )

            class BookingRules(BaseModel):
                model_config = ConfigDict(defer_build=True)
                booking_rule: list[
                    "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.BookingRules.BookingRule"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "BookingRule",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class BookingRule(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    lengths_of_stay: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.BookingRules.BookingRule.LengthsOfStay"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "LengthsOfStay",
                            "type": "Element",
                        },
                    )
                    dow_restrictions: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.BookingRules.BookingRule.DowRestrictions"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "DOW_Restrictions",
                            "type": "Element",
                        },
                    )
                    restriction_status: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.BookingRules.BookingRule.RestrictionStatus"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "RestrictionStatus",
                            "type": "Element",
                        },
                    )
                    code_context: Optional[BookingRuleCodeContext] = field(
                        default=None,
                        metadata={
                            "name": "CodeContext",
                            "type": "Attribute",
                        },
                    )
                    code: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Code",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 8,
                        },
                    )
                    start: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Start",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    end: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "End",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )

                    class LengthsOfStay(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        length_of_stay: list[
                            "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.BookingRules.BookingRule.LengthsOfStay.LengthOfStay"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "LengthOfStay",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class LengthOfStay(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            time: str = field(
                                metadata={
                                    "name": "Time",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                }
                            )
                            time_unit: LengthOfStayTimeUnit = field(
                                metadata={
                                    "name": "TimeUnit",
                                    "type": "Attribute",
                                    "required": True,
                                }
                            )
                            min_max_message_type: LengthOfStayMinMaxMessageType1 = (
                                field(
                                    metadata={
                                        "name": "MinMaxMessageType",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )
                            )

                    class DowRestrictions(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        arrival_days_of_week: Optional[
                            "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.BookingRules.BookingRule.DowRestrictions.ArrivalDaysOfWeek"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "ArrivalDaysOfWeek",
                                "type": "Element",
                            },
                        )
                        departure_days_of_week: Optional[
                            "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.BookingRules.BookingRule.DowRestrictions.DepartureDaysOfWeek"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "DepartureDaysOfWeek",
                                "type": "Element",
                            },
                        )

                        class ArrivalDaysOfWeek(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            mon: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Mon",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            tue: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Tue",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            weds: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Weds",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            thur: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Thur",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            fri: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Fri",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            sat: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Sat",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            sun: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Sun",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )

                        class DepartureDaysOfWeek(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            mon: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Mon",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            tue: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Tue",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            weds: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Weds",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            thur: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Thur",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            fri: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Fri",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            sat: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Sat",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            sun: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Sun",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )

                    class RestrictionStatus(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        restriction: Optional[RestrictionStatusRestriction] = field(
                            default=None,
                            metadata={
                                "name": "Restriction",
                                "type": "Attribute",
                            },
                        )
                        status: Optional[RestrictionStatusStatus] = field(
                            default=None,
                            metadata={
                                "name": "Status",
                                "type": "Attribute",
                            },
                        )

            class Rates(BaseModel):
                model_config = ConfigDict(defer_build=True)
                rate: list["OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Rates.Rate"] = (
                    field(
                        default_factory=list,
                        metadata={
                            "name": "Rate",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )
                )

                class Rate(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    base_by_guest_amts: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Rates.Rate.BaseByGuestAmts"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "BaseByGuestAmts",
                            "type": "Element",
                        },
                    )
                    additional_guest_amounts: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Rates.Rate.AdditionalGuestAmounts"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "AdditionalGuestAmounts",
                            "type": "Element",
                        },
                    )
                    rate_description: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Rates.Rate.RateDescription"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "RateDescription",
                            "type": "Element",
                        },
                    )
                    meals_included: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Rates.Rate.MealsIncluded"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "MealsIncluded",
                            "type": "Element",
                        },
                    )
                    min_guest_applicable: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "MinGuestApplicable",
                            "type": "Attribute",
                            "pattern": r"[0-9]+",
                        },
                    )
                    start: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Start",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    end: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "End",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    rate_time_unit: Optional[RateRateTimeUnit] = field(
                        default=None,
                        metadata={
                            "name": "RateTimeUnit",
                            "type": "Attribute",
                        },
                    )
                    unit_multiplier: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "UnitMultiplier",
                            "type": "Attribute",
                            "pattern": r"[0-9]+",
                        },
                    )
                    mon: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Mon",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    tue: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Tue",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    weds: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Weds",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    thur: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Thur",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    fri: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Fri",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    sat: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Sat",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    sun: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Sun",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    duration: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Duration",
                            "type": "Attribute",
                            "pattern": r"P[0-9]+N",
                        },
                    )
                    inv_type_code: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "InvTypeCode",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 8,
                        },
                    )

                    class BaseByGuestAmts(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        base_by_guest_amt: list[
                            "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Rates.Rate.BaseByGuestAmts.BaseByGuestAmt"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "BaseByGuestAmt",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class BaseByGuestAmt(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            number_of_guests: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "NumberOfGuests",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            amount_after_tax: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "AmountAfterTax",
                                    "type": "Attribute",
                                    "min_exclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                },
                            )
                            currency_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "min_length": 3,
                                    "max_length": 3,
                                },
                            )
                            type_value: Optional[BaseByGuestAmtType] = field(
                                default=None,
                                metadata={
                                    "name": "Type",
                                    "type": "Attribute",
                                },
                            )
                            age_qualifying_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "AgeQualifyingCode",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )

                    class AdditionalGuestAmounts(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        additional_guest_amount: list[
                            "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Rates.Rate.AdditionalGuestAmounts.AdditionalGuestAmount"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "AdditionalGuestAmount",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class AdditionalGuestAmount(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            amount: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Amount",
                                    "type": "Attribute",
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                },
                            )
                            age_qualifying_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "AgeQualifyingCode",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            min_age: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "MinAge",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            max_age: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "MaxAge",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )

                    class RateDescription(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        list_item: list[
                            "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Rates.Rate.RateDescription.ListItem"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "ListItem",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )
                        name: RateDescriptionName = field(
                            metadata={
                                "name": "Name",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

                        class ListItem(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                    "min_length": 1,
                                },
                            )
                            list_item: str = field(
                                metadata={
                                    "name": "ListItem",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            language: str = field(
                                metadata={
                                    "name": "Language",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[a-z][a-z]",
                                }
                            )

                    class MealsIncluded(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        breakfast: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Breakfast",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )
                        lunch: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Lunch",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )
                        dinner: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Dinner",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )
                        meal_plan_codes: Optional[MealsIncludedMealPlanCodes] = field(
                            default=None,
                            metadata={
                                "name": "MealPlanCodes",
                                "type": "Attribute",
                            },
                        )
                        meal_plan_indicator: Optional[
                            MealsIncludedMealPlanIndicator
                        ] = field(
                            default=None,
                            metadata={
                                "name": "MealPlanIndicator",
                                "type": "Attribute",
                            },
                        )

            class Supplements(BaseModel):
                model_config = ConfigDict(defer_build=True)
                supplement: list[
                    "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Supplements.Supplement"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "Supplement",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class Supplement(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    prerequisite_inventory: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Supplements.Supplement.PrerequisiteInventory"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "PrerequisiteInventory",
                            "type": "Element",
                        },
                    )
                    description: list[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Supplements.Supplement.Description"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "Description",
                            "type": "Element",
                            "max_occurs": 5,
                        },
                    )
                    add_to_basic_rate_indicator: Optional[
                        SupplementAddToBasicRateIndicator
                    ] = field(
                        default=None,
                        metadata={
                            "name": "AddToBasicRateIndicator",
                            "type": "Attribute",
                        },
                    )
                    charge_type_code: Optional[SupplementChargeTypeCode] = field(
                        default=None,
                        metadata={
                            "name": "ChargeTypeCode",
                            "type": "Attribute",
                        },
                    )
                    amount: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Amount",
                            "type": "Attribute",
                            "min_inclusive": "0.0",
                            "pattern": r"[0-9]*\.?[0-9]*",
                        },
                    )
                    inv_type: SupplementInvType = field(
                        metadata={
                            "name": "InvType",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    inv_code: str = field(
                        metadata={
                            "name": "InvCode",
                            "type": "Attribute",
                            "required": True,
                            "min_length": 1,
                            "max_length": 16,
                        }
                    )
                    mandatory_indicator: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "MandatoryIndicator",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    start: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Start",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    end: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "End",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )

                    class Description(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        list_item: list[str] = field(
                            default_factory=list,
                            metadata={
                                "name": "ListItem",
                                "type": "Element",
                                "min_length": 1,
                            },
                        )
                        image: list[str] = field(
                            default_factory=list,
                            metadata={
                                "name": "Image",
                                "type": "Element",
                                "pattern": r"https?://.+",
                            },
                        )
                        text: list[
                            "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Supplements.Supplement.Description.Text"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "Text",
                                "type": "Element",
                            },
                        )
                        url: list[str] = field(
                            default_factory=list,
                            metadata={
                                "name": "URL",
                                "type": "Element",
                                "pattern": r"https?://.+",
                            },
                        )
                        name: DescriptionName = field(
                            metadata={
                                "name": "Name",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

                        class Text(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                    "min_length": 1,
                                },
                            )
                            text_format: TextTextFormat2 = field(
                                metadata={
                                    "name": "TextFormat",
                                    "type": "Attribute",
                                    "required": True,
                                }
                            )
                            language: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Language",
                                    "type": "Attribute",
                                    "pattern": r"[a-z][a-z]",
                                },
                            )

                    class PrerequisiteInventory(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        inv_code: str = field(
                            metadata={
                                "name": "InvCode",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 16,
                            }
                        )
                        inv_type: PrerequisiteInventoryInvType = field(
                            metadata={
                                "name": "InvType",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

            class Offers(BaseModel):
                model_config = ConfigDict(defer_build=True)
                offer: list[
                    "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "Offer",
                        "type": "Element",
                        "min_occurs": 1,
                        "max_occurs": 3,
                    },
                )

                class Offer(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    offer_rules: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.OfferRules"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "OfferRules",
                            "type": "Element",
                        },
                    )
                    discount: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.Discount"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Discount",
                            "type": "Element",
                        },
                    )
                    guests: Optional[
                        "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.Guests"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Guests",
                            "type": "Element",
                        },
                    )

                    class OfferRules(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        offer_rule: Optional[
                            "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "OfferRule",
                                "type": "Element",
                            },
                        )

                        class OfferRule(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            lengths_of_stay: Optional[
                                "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.LengthsOfStay"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "LengthsOfStay",
                                    "type": "Element",
                                },
                            )
                            dow_restrictions: Optional[
                                "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.DowRestrictions"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "DOW_Restrictions",
                                    "type": "Element",
                                },
                            )
                            occupancy: list[
                                "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.Occupancy"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "Occupancy",
                                    "type": "Element",
                                    "min_occurs": 1,
                                },
                            )
                            min_advanced_booking_offset: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "MinAdvancedBookingOffset",
                                    "type": "Attribute",
                                    "pattern": r"P[0-9]+D",
                                },
                            )
                            max_advanced_booking_offset: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "MaxAdvancedBookingOffset",
                                    "type": "Attribute",
                                    "pattern": r"P[0-9]+D",
                                },
                            )

                            class LengthsOfStay(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                length_of_stay: list[
                                    "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.LengthsOfStay.LengthOfStay"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "LengthOfStay",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class LengthOfStay(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    time: str = field(
                                        metadata={
                                            "name": "Time",
                                            "type": "Attribute",
                                            "required": True,
                                            "min_inclusive": "0.0",
                                            "pattern": r"[0-9]*\.?[0-9]*",
                                        }
                                    )
                                    time_unit: LengthOfStayTimeUnit = field(
                                        metadata={
                                            "name": "TimeUnit",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                    min_max_message_type: LengthOfStayMinMaxMessageType2 = field(
                                        metadata={
                                            "name": "MinMaxMessageType",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )

                            class DowRestrictions(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                arrival_days_of_week: Optional[
                                    "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.DowRestrictions.ArrivalDaysOfWeek"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "ArrivalDaysOfWeek",
                                        "type": "Element",
                                    },
                                )
                                departure_days_of_week: Optional[
                                    "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.DowRestrictions.DepartureDaysOfWeek"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "DepartureDaysOfWeek",
                                        "type": "Element",
                                    },
                                )

                                class ArrivalDaysOfWeek(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    mon: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Mon",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    tue: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Tue",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    weds: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Weds",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    thur: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Thur",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    fri: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Fri",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    sat: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Sat",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    sun: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Sun",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )

                                class DepartureDaysOfWeek(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    mon: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Mon",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    tue: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Tue",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    weds: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Weds",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    thur: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Thur",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    fri: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Fri",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    sat: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Sat",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    sun: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Sun",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )

                            class Occupancy(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                age_qualifying_code: OccupancyAgeQualifyingCode = field(
                                    metadata={
                                        "name": "AgeQualifyingCode",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )
                                min_age: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "MinAge",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )
                                max_age: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "MaxAge",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )
                                min_occupancy: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "MinOccupancy",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )
                                max_occupancy: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "MaxOccupancy",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )

                    class Discount(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        percent: DiscountPercent = field(
                            metadata={
                                "name": "Percent",
                                "type": "Attribute",
                                "required": True,
                            }
                        )
                        nights_required: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "NightsRequired",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        nights_discounted: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "NightsDiscounted",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        discount_pattern: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "DiscountPattern",
                                "type": "Attribute",
                                "pattern": r"0*1*",
                            },
                        )

                    class Guests(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        guest: "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Offers.Offer.Guests.Guest" = field(
                            metadata={
                                "name": "Guest",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class Guest(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            age_qualifying_code: str = field(
                                metadata={
                                    "name": "AgeQualifyingCode",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            max_age: str = field(
                                metadata={
                                    "name": "MaxAge",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            min_count: str = field(
                                metadata={
                                    "name": "MinCount",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            first_qualifying_position: GuestFirstQualifyingPosition = (
                                field(
                                    metadata={
                                        "name": "FirstQualifyingPosition",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )
                            )
                            last_qualifying_position: str = field(
                                metadata={
                                    "name": "LastQualifyingPosition",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )

            class Description(BaseModel):
                model_config = ConfigDict(defer_build=True)
                list_item: list[str] = field(
                    default_factory=list,
                    metadata={
                        "name": "ListItem",
                        "type": "Element",
                        "min_length": 1,
                    },
                )
                image: list[str] = field(
                    default_factory=list,
                    metadata={
                        "name": "Image",
                        "type": "Element",
                        "pattern": r"https?://.+",
                    },
                )
                text: list[
                    "OtaHotelRatePlanNotifRq.RatePlans.RatePlan.Description.Text"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "Text",
                        "type": "Element",
                    },
                )
                url: list[str] = field(
                    default_factory=list,
                    metadata={
                        "name": "URL",
                        "type": "Element",
                        "pattern": r"https?://.+",
                    },
                )
                name: DescriptionName = field(
                    metadata={
                        "name": "Name",
                        "type": "Attribute",
                        "required": True,
                    }
                )

                class Text(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    value: str = field(
                        default="",
                        metadata={
                            "required": True,
                            "min_length": 1,
                        },
                    )
                    text_format: TextTextFormat2 = field(
                        metadata={
                            "name": "TextFormat",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    language: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Language",
                            "type": "Attribute",
                            "pattern": r"[a-z][a-z]",
                        },
                    )


class OtaHotelRatePlanNotifRs(BaseModel):
    class Meta:
        name = "OTA_HotelRatePlanNotifRS"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    errors: Optional["OtaHotelRatePlanNotifRs.Errors"] = field(
        default=None,
        metadata={
            "name": "Errors",
            "type": "Element",
        },
    )
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaHotelRatePlanNotifRs.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Errors(BaseModel):
        model_config = ConfigDict(defer_build=True)
        error: list["OtaHotelRatePlanNotifRs.Errors.Error"] = field(
            default_factory=list,
            metadata={
                "name": "Error",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Error(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: ErrorType = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaHotelRatePlanNotifRs.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            record_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RecordID",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )


class OtaHotelRatePlanRs(BaseModel):
    class Meta:
        name = "OTA_HotelRatePlanRS"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    errors: Optional["OtaHotelRatePlanRs.Errors"] = field(
        default=None,
        metadata={
            "name": "Errors",
            "type": "Element",
        },
    )
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaHotelRatePlanRs.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    rate_plans: Optional["OtaHotelRatePlanRs.RatePlans"] = field(
        default=None,
        metadata={
            "name": "RatePlans",
            "type": "Element",
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Errors(BaseModel):
        model_config = ConfigDict(defer_build=True)
        error: list["OtaHotelRatePlanRs.Errors.Error"] = field(
            default_factory=list,
            metadata={
                "name": "Error",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Error(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: ErrorType = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaHotelRatePlanRs.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            record_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RecordID",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class RatePlans(BaseModel):
        model_config = ConfigDict(defer_build=True)
        rate_plan: list["OtaHotelRatePlanRs.RatePlans.RatePlan"] = field(
            default_factory=list,
            metadata={
                "name": "RatePlan",
                "type": "Element",
                "min_occurs": 1,
            },
        )
        hotel_code: str = field(
            metadata={
                "name": "HotelCode",
                "type": "Attribute",
                "required": True,
                "min_length": 1,
                "max_length": 16,
            }
        )
        hotel_name: Optional[str] = field(
            default=None,
            metadata={
                "name": "HotelName",
                "type": "Attribute",
                "min_length": 1,
                "max_length": 128,
            },
        )

        class RatePlan(BaseModel):
            model_config = ConfigDict(defer_build=True)
            booking_rules: Optional[
                "OtaHotelRatePlanRs.RatePlans.RatePlan.BookingRules"
            ] = field(
                default=None,
                metadata={
                    "name": "BookingRules",
                    "type": "Element",
                },
            )
            rates: Optional["OtaHotelRatePlanRs.RatePlans.RatePlan.Rates"] = field(
                default=None,
                metadata={
                    "name": "Rates",
                    "type": "Element",
                },
            )
            supplements: Optional[
                "OtaHotelRatePlanRs.RatePlans.RatePlan.Supplements"
            ] = field(
                default=None,
                metadata={
                    "name": "Supplements",
                    "type": "Element",
                },
            )
            offers: Optional["OtaHotelRatePlanRs.RatePlans.RatePlan.Offers"] = field(
                default=None,
                metadata={
                    "name": "Offers",
                    "type": "Element",
                },
            )
            description: list["OtaHotelRatePlanRs.RatePlans.RatePlan.Description"] = (
                field(
                    default_factory=list,
                    metadata={
                        "name": "Description",
                        "type": "Element",
                        "max_occurs": 5,
                    },
                )
            )
            start: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Start",
                    "type": "Attribute",
                    "pattern": r"\S+",
                },
            )
            end: Optional[str] = field(
                default=None,
                metadata={
                    "name": "End",
                    "type": "Attribute",
                    "pattern": r"\S+",
                },
            )
            rate_plan_notif_type: Optional[RatePlanRatePlanNotifType] = field(
                default=None,
                metadata={
                    "name": "RatePlanNotifType",
                    "type": "Attribute",
                },
            )
            currency_code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "CurrencyCode",
                    "type": "Attribute",
                    "min_length": 3,
                    "max_length": 3,
                },
            )
            rate_plan_code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RatePlanCode",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            rate_plan_type: Optional[RatePlanRatePlanType] = field(
                default=None,
                metadata={
                    "name": "RatePlanType",
                    "type": "Attribute",
                },
            )
            rate_plan_category: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RatePlanCategory",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            rate_plan_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RatePlanID",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            rate_plan_qualifier: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RatePlanQualifier",
                    "type": "Attribute",
                    "pattern": r"\S+",
                },
            )

            class BookingRules(BaseModel):
                model_config = ConfigDict(defer_build=True)
                booking_rule: list[
                    "OtaHotelRatePlanRs.RatePlans.RatePlan.BookingRules.BookingRule"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "BookingRule",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class BookingRule(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    lengths_of_stay: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.BookingRules.BookingRule.LengthsOfStay"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "LengthsOfStay",
                            "type": "Element",
                        },
                    )
                    dow_restrictions: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.BookingRules.BookingRule.DowRestrictions"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "DOW_Restrictions",
                            "type": "Element",
                        },
                    )
                    restriction_status: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.BookingRules.BookingRule.RestrictionStatus"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "RestrictionStatus",
                            "type": "Element",
                        },
                    )
                    code_context: Optional[BookingRuleCodeContext] = field(
                        default=None,
                        metadata={
                            "name": "CodeContext",
                            "type": "Attribute",
                        },
                    )
                    code: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Code",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 8,
                        },
                    )
                    start: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Start",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    end: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "End",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )

                    class LengthsOfStay(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        length_of_stay: list[
                            "OtaHotelRatePlanRs.RatePlans.RatePlan.BookingRules.BookingRule.LengthsOfStay.LengthOfStay"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "LengthOfStay",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class LengthOfStay(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            time: str = field(
                                metadata={
                                    "name": "Time",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                }
                            )
                            time_unit: LengthOfStayTimeUnit = field(
                                metadata={
                                    "name": "TimeUnit",
                                    "type": "Attribute",
                                    "required": True,
                                }
                            )
                            min_max_message_type: LengthOfStayMinMaxMessageType1 = (
                                field(
                                    metadata={
                                        "name": "MinMaxMessageType",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )
                            )

                    class DowRestrictions(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        arrival_days_of_week: Optional[
                            "OtaHotelRatePlanRs.RatePlans.RatePlan.BookingRules.BookingRule.DowRestrictions.ArrivalDaysOfWeek"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "ArrivalDaysOfWeek",
                                "type": "Element",
                            },
                        )
                        departure_days_of_week: Optional[
                            "OtaHotelRatePlanRs.RatePlans.RatePlan.BookingRules.BookingRule.DowRestrictions.DepartureDaysOfWeek"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "DepartureDaysOfWeek",
                                "type": "Element",
                            },
                        )

                        class ArrivalDaysOfWeek(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            mon: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Mon",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            tue: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Tue",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            weds: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Weds",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            thur: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Thur",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            fri: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Fri",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            sat: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Sat",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            sun: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Sun",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )

                        class DepartureDaysOfWeek(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            mon: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Mon",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            tue: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Tue",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            weds: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Weds",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            thur: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Thur",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            fri: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Fri",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            sat: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Sat",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )
                            sun: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Sun",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )

                    class RestrictionStatus(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        restriction: Optional[RestrictionStatusRestriction] = field(
                            default=None,
                            metadata={
                                "name": "Restriction",
                                "type": "Attribute",
                            },
                        )
                        status: Optional[RestrictionStatusStatus] = field(
                            default=None,
                            metadata={
                                "name": "Status",
                                "type": "Attribute",
                            },
                        )

            class Rates(BaseModel):
                model_config = ConfigDict(defer_build=True)
                rate: list["OtaHotelRatePlanRs.RatePlans.RatePlan.Rates.Rate"] = field(
                    default_factory=list,
                    metadata={
                        "name": "Rate",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class Rate(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    base_by_guest_amts: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.Rates.Rate.BaseByGuestAmts"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "BaseByGuestAmts",
                            "type": "Element",
                        },
                    )
                    additional_guest_amounts: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.Rates.Rate.AdditionalGuestAmounts"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "AdditionalGuestAmounts",
                            "type": "Element",
                        },
                    )
                    rate_description: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.Rates.Rate.RateDescription"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "RateDescription",
                            "type": "Element",
                        },
                    )
                    meals_included: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.Rates.Rate.MealsIncluded"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "MealsIncluded",
                            "type": "Element",
                        },
                    )
                    min_guest_applicable: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "MinGuestApplicable",
                            "type": "Attribute",
                            "pattern": r"[0-9]+",
                        },
                    )
                    start: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Start",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    end: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "End",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    rate_time_unit: Optional[RateRateTimeUnit] = field(
                        default=None,
                        metadata={
                            "name": "RateTimeUnit",
                            "type": "Attribute",
                        },
                    )
                    unit_multiplier: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "UnitMultiplier",
                            "type": "Attribute",
                            "pattern": r"[0-9]+",
                        },
                    )
                    mon: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Mon",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    tue: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Tue",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    weds: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Weds",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    thur: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Thur",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    fri: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Fri",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    sat: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Sat",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    sun: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Sun",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    duration: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Duration",
                            "type": "Attribute",
                            "pattern": r"P[0-9]+N",
                        },
                    )
                    inv_type_code: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "InvTypeCode",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 8,
                        },
                    )

                    class BaseByGuestAmts(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        base_by_guest_amt: list[
                            "OtaHotelRatePlanRs.RatePlans.RatePlan.Rates.Rate.BaseByGuestAmts.BaseByGuestAmt"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "BaseByGuestAmt",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class BaseByGuestAmt(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            number_of_guests: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "NumberOfGuests",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            amount_after_tax: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "AmountAfterTax",
                                    "type": "Attribute",
                                    "min_exclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                },
                            )
                            currency_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "min_length": 3,
                                    "max_length": 3,
                                },
                            )
                            type_value: Optional[BaseByGuestAmtType] = field(
                                default=None,
                                metadata={
                                    "name": "Type",
                                    "type": "Attribute",
                                },
                            )
                            age_qualifying_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "AgeQualifyingCode",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )

                    class AdditionalGuestAmounts(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        additional_guest_amount: list[
                            "OtaHotelRatePlanRs.RatePlans.RatePlan.Rates.Rate.AdditionalGuestAmounts.AdditionalGuestAmount"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "AdditionalGuestAmount",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class AdditionalGuestAmount(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            amount: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Amount",
                                    "type": "Attribute",
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                },
                            )
                            age_qualifying_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "AgeQualifyingCode",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            min_age: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "MinAge",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            max_age: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "MaxAge",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )

                    class RateDescription(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        list_item: list[
                            "OtaHotelRatePlanRs.RatePlans.RatePlan.Rates.Rate.RateDescription.ListItem"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "ListItem",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )
                        name: RateDescriptionName = field(
                            metadata={
                                "name": "Name",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

                        class ListItem(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                    "min_length": 1,
                                },
                            )
                            list_item: str = field(
                                metadata={
                                    "name": "ListItem",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            language: str = field(
                                metadata={
                                    "name": "Language",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[a-z][a-z]",
                                }
                            )

                    class MealsIncluded(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        breakfast: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Breakfast",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )
                        lunch: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Lunch",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )
                        dinner: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Dinner",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )
                        meal_plan_codes: Optional[MealsIncludedMealPlanCodes] = field(
                            default=None,
                            metadata={
                                "name": "MealPlanCodes",
                                "type": "Attribute",
                            },
                        )
                        meal_plan_indicator: Optional[
                            MealsIncludedMealPlanIndicator
                        ] = field(
                            default=None,
                            metadata={
                                "name": "MealPlanIndicator",
                                "type": "Attribute",
                            },
                        )

            class Supplements(BaseModel):
                model_config = ConfigDict(defer_build=True)
                supplement: list[
                    "OtaHotelRatePlanRs.RatePlans.RatePlan.Supplements.Supplement"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "Supplement",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class Supplement(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    prerequisite_inventory: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.Supplements.Supplement.PrerequisiteInventory"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "PrerequisiteInventory",
                            "type": "Element",
                        },
                    )
                    description: list[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.Supplements.Supplement.Description"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "Description",
                            "type": "Element",
                            "max_occurs": 5,
                        },
                    )
                    add_to_basic_rate_indicator: Optional[
                        SupplementAddToBasicRateIndicator
                    ] = field(
                        default=None,
                        metadata={
                            "name": "AddToBasicRateIndicator",
                            "type": "Attribute",
                        },
                    )
                    charge_type_code: Optional[SupplementChargeTypeCode] = field(
                        default=None,
                        metadata={
                            "name": "ChargeTypeCode",
                            "type": "Attribute",
                        },
                    )
                    amount: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Amount",
                            "type": "Attribute",
                            "min_inclusive": "0.0",
                            "pattern": r"[0-9]*\.?[0-9]*",
                        },
                    )
                    inv_type: SupplementInvType = field(
                        metadata={
                            "name": "InvType",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    inv_code: str = field(
                        metadata={
                            "name": "InvCode",
                            "type": "Attribute",
                            "required": True,
                            "min_length": 1,
                            "max_length": 16,
                        }
                    )
                    mandatory_indicator: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "MandatoryIndicator",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    start: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Start",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )
                    end: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "End",
                            "type": "Attribute",
                            "pattern": r"\S+",
                        },
                    )

                    class Description(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        list_item: list[str] = field(
                            default_factory=list,
                            metadata={
                                "name": "ListItem",
                                "type": "Element",
                                "min_length": 1,
                            },
                        )
                        image: list[str] = field(
                            default_factory=list,
                            metadata={
                                "name": "Image",
                                "type": "Element",
                                "pattern": r"https?://.+",
                            },
                        )
                        text: list[
                            "OtaHotelRatePlanRs.RatePlans.RatePlan.Supplements.Supplement.Description.Text"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "Text",
                                "type": "Element",
                            },
                        )
                        url: list[str] = field(
                            default_factory=list,
                            metadata={
                                "name": "URL",
                                "type": "Element",
                                "pattern": r"https?://.+",
                            },
                        )
                        name: DescriptionName = field(
                            metadata={
                                "name": "Name",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

                        class Text(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                    "min_length": 1,
                                },
                            )
                            text_format: TextTextFormat2 = field(
                                metadata={
                                    "name": "TextFormat",
                                    "type": "Attribute",
                                    "required": True,
                                }
                            )
                            language: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Language",
                                    "type": "Attribute",
                                    "pattern": r"[a-z][a-z]",
                                },
                            )

                    class PrerequisiteInventory(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        inv_code: str = field(
                            metadata={
                                "name": "InvCode",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 16,
                            }
                        )
                        inv_type: PrerequisiteInventoryInvType = field(
                            metadata={
                                "name": "InvType",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

            class Offers(BaseModel):
                model_config = ConfigDict(defer_build=True)
                offer: list["OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer"] = (
                    field(
                        default_factory=list,
                        metadata={
                            "name": "Offer",
                            "type": "Element",
                            "min_occurs": 1,
                            "max_occurs": 3,
                        },
                    )
                )

                class Offer(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    offer_rules: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.OfferRules"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "OfferRules",
                            "type": "Element",
                        },
                    )
                    discount: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.Discount"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Discount",
                            "type": "Element",
                        },
                    )
                    guests: Optional[
                        "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.Guests"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Guests",
                            "type": "Element",
                        },
                    )

                    class OfferRules(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        offer_rule: Optional[
                            "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "OfferRule",
                                "type": "Element",
                            },
                        )

                        class OfferRule(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            lengths_of_stay: Optional[
                                "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.LengthsOfStay"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "LengthsOfStay",
                                    "type": "Element",
                                },
                            )
                            dow_restrictions: Optional[
                                "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.DowRestrictions"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "DOW_Restrictions",
                                    "type": "Element",
                                },
                            )
                            occupancy: list[
                                "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.Occupancy"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "Occupancy",
                                    "type": "Element",
                                    "min_occurs": 1,
                                },
                            )
                            min_advanced_booking_offset: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "MinAdvancedBookingOffset",
                                    "type": "Attribute",
                                    "pattern": r"P[0-9]+D",
                                },
                            )
                            max_advanced_booking_offset: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "MaxAdvancedBookingOffset",
                                    "type": "Attribute",
                                    "pattern": r"P[0-9]+D",
                                },
                            )

                            class LengthsOfStay(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                length_of_stay: list[
                                    "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.LengthsOfStay.LengthOfStay"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "LengthOfStay",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class LengthOfStay(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    time: str = field(
                                        metadata={
                                            "name": "Time",
                                            "type": "Attribute",
                                            "required": True,
                                            "min_inclusive": "0.0",
                                            "pattern": r"[0-9]*\.?[0-9]*",
                                        }
                                    )
                                    time_unit: LengthOfStayTimeUnit = field(
                                        metadata={
                                            "name": "TimeUnit",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                    min_max_message_type: LengthOfStayMinMaxMessageType2 = field(
                                        metadata={
                                            "name": "MinMaxMessageType",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )

                            class DowRestrictions(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                arrival_days_of_week: Optional[
                                    "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.DowRestrictions.ArrivalDaysOfWeek"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "ArrivalDaysOfWeek",
                                        "type": "Element",
                                    },
                                )
                                departure_days_of_week: Optional[
                                    "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.OfferRules.OfferRule.DowRestrictions.DepartureDaysOfWeek"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "DepartureDaysOfWeek",
                                        "type": "Element",
                                    },
                                )

                                class ArrivalDaysOfWeek(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    mon: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Mon",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    tue: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Tue",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    weds: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Weds",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    thur: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Thur",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    fri: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Fri",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    sat: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Sat",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    sun: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Sun",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )

                                class DepartureDaysOfWeek(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    mon: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Mon",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    tue: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Tue",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    weds: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Weds",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    thur: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Thur",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    fri: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Fri",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    sat: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Sat",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    sun: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Sun",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )

                            class Occupancy(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                age_qualifying_code: OccupancyAgeQualifyingCode = field(
                                    metadata={
                                        "name": "AgeQualifyingCode",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )
                                min_age: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "MinAge",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )
                                max_age: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "MaxAge",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )
                                min_occupancy: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "MinOccupancy",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )
                                max_occupancy: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "MaxOccupancy",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )

                    class Discount(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        percent: DiscountPercent = field(
                            metadata={
                                "name": "Percent",
                                "type": "Attribute",
                                "required": True,
                            }
                        )
                        nights_required: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "NightsRequired",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        nights_discounted: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "NightsDiscounted",
                                "type": "Attribute",
                                "pattern": r"[0-9]+",
                            },
                        )
                        discount_pattern: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "DiscountPattern",
                                "type": "Attribute",
                                "pattern": r"0*1*",
                            },
                        )

                    class Guests(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        guest: "OtaHotelRatePlanRs.RatePlans.RatePlan.Offers.Offer.Guests.Guest" = field(
                            metadata={
                                "name": "Guest",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class Guest(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            age_qualifying_code: str = field(
                                metadata={
                                    "name": "AgeQualifyingCode",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            max_age: str = field(
                                metadata={
                                    "name": "MaxAge",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            min_count: str = field(
                                metadata={
                                    "name": "MinCount",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            first_qualifying_position: GuestFirstQualifyingPosition = (
                                field(
                                    metadata={
                                        "name": "FirstQualifyingPosition",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )
                            )
                            last_qualifying_position: str = field(
                                metadata={
                                    "name": "LastQualifyingPosition",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )

            class Description(BaseModel):
                model_config = ConfigDict(defer_build=True)
                list_item: list[str] = field(
                    default_factory=list,
                    metadata={
                        "name": "ListItem",
                        "type": "Element",
                        "min_length": 1,
                    },
                )
                image: list[str] = field(
                    default_factory=list,
                    metadata={
                        "name": "Image",
                        "type": "Element",
                        "pattern": r"https?://.+",
                    },
                )
                text: list["OtaHotelRatePlanRs.RatePlans.RatePlan.Description.Text"] = (
                    field(
                        default_factory=list,
                        metadata={
                            "name": "Text",
                            "type": "Element",
                        },
                    )
                )
                url: list[str] = field(
                    default_factory=list,
                    metadata={
                        "name": "URL",
                        "type": "Element",
                        "pattern": r"https?://.+",
                    },
                )
                name: DescriptionName = field(
                    metadata={
                        "name": "Name",
                        "type": "Attribute",
                        "required": True,
                    }
                )

                class Text(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    value: str = field(
                        default="",
                        metadata={
                            "required": True,
                            "min_length": 1,
                        },
                    )
                    text_format: TextTextFormat2 = field(
                        metadata={
                            "name": "TextFormat",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    language: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "Language",
                            "type": "Attribute",
                            "pattern": r"[a-z][a-z]",
                        },
                    )


class OtaHotelResNotifRq(BaseModel):
    class Meta:
        name = "OTA_HotelResNotifRQ"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    hotel_reservations: "OtaHotelResNotifRq.HotelReservations" = field(
        metadata={
            "name": "HotelReservations",
            "type": "Element",
            "required": True,
        }
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class HotelReservations(BaseModel):
        model_config = ConfigDict(defer_build=True)
        hotel_reservation: list[
            "OtaHotelResNotifRq.HotelReservations.HotelReservation"
        ] = field(
            default_factory=list,
            metadata={
                "name": "HotelReservation",
                "type": "Element",
            },
        )

        class HotelReservation(BaseModel):
            model_config = ConfigDict(defer_build=True)
            unique_id: "OtaHotelResNotifRq.HotelReservations.HotelReservation.UniqueId" = field(
                metadata={
                    "name": "UniqueID",
                    "type": "Element",
                    "required": True,
                }
            )
            room_stays: Optional[
                "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays"
            ] = field(
                default=None,
                metadata={
                    "name": "RoomStays",
                    "type": "Element",
                },
            )
            services: Optional[
                "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services"
            ] = field(
                default=None,
                metadata={
                    "name": "Services",
                    "type": "Element",
                },
            )
            res_guests: Optional[
                "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests"
            ] = field(
                default=None,
                metadata={
                    "name": "ResGuests",
                    "type": "Element",
                },
            )
            res_global_info: Optional[
                "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo"
            ] = field(
                default=None,
                metadata={
                    "name": "ResGlobalInfo",
                    "type": "Element",
                },
            )
            create_date_time: str = field(
                metadata={
                    "name": "CreateDateTime",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"\S+",
                }
            )
            last_modify_date_time: Optional[str] = field(
                default=None,
                metadata={
                    "name": "LastModifyDateTime",
                    "type": "Attribute",
                    "pattern": r"\S+",
                },
            )
            res_status: HotelReservationResStatus = field(
                metadata={
                    "name": "ResStatus",
                    "type": "Attribute",
                    "required": True,
                }
            )
            room_stay_reservation: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RoomStayReservation",
                    "type": "Attribute",
                    "pattern": r"\S+",
                },
            )

            class UniqueId(BaseModel):
                model_config = ConfigDict(defer_build=True)
                type_value: UniqueIdType2 = field(
                    metadata={
                        "name": "Type",
                        "type": "Attribute",
                        "required": True,
                    }
                )
                id: str = field(
                    metadata={
                        "name": "ID",
                        "type": "Attribute",
                        "required": True,
                        "min_length": 1,
                        "max_length": 32,
                    }
                )

            class RoomStays(BaseModel):
                model_config = ConfigDict(defer_build=True)
                room_stay: list[
                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "RoomStay",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class RoomStay(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    room_types: Optional[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RoomTypes"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "RoomTypes",
                            "type": "Element",
                        },
                    )
                    rate_plans: Optional[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RatePlans"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "RatePlans",
                            "type": "Element",
                        },
                    )
                    room_rates: Optional[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RoomRates"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "RoomRates",
                            "type": "Element",
                        },
                    )
                    guest_counts: Optional[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.GuestCounts"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "GuestCounts",
                            "type": "Element",
                        },
                    )
                    time_span: "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.TimeSpan" = field(
                        metadata={
                            "name": "TimeSpan",
                            "type": "Element",
                            "required": True,
                        }
                    )
                    guarantee: Optional[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.Guarantee"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Guarantee",
                            "type": "Element",
                        },
                    )
                    total: Optional[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.Total"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Total",
                            "type": "Element",
                        },
                    )
                    service_rphs: Optional[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.ServiceRphs"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "ServiceRPHs",
                            "type": "Element",
                        },
                    )
                    room_stay_group_id: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "RoomStayGroupID",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 32,
                        },
                    )

                    class RoomTypes(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        room_type: "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RoomTypes.RoomType" = field(
                            metadata={
                                "name": "RoomType",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class RoomType(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            room_type_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "RoomTypeCode",
                                    "type": "Attribute",
                                    "min_length": 1,
                                    "max_length": 8,
                                },
                            )
                            room_classification_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "RoomClassificationCode",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            room_type: Optional[RoomTypeRoomType] = field(
                                default=None,
                                metadata={
                                    "name": "RoomType",
                                    "type": "Attribute",
                                },
                            )

                    class RatePlans(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        rate_plan: "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RatePlans.RatePlan" = field(
                            metadata={
                                "name": "RatePlan",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class RatePlan(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            commission: Optional[
                                "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RatePlans.RatePlan.Commission"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "Commission",
                                    "type": "Element",
                                },
                            )
                            meals_included: Optional[
                                "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RatePlans.RatePlan.MealsIncluded"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "MealsIncluded",
                                    "type": "Element",
                                },
                            )
                            rate_plan_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "RatePlanCode",
                                    "type": "Attribute",
                                    "min_length": 1,
                                    "max_length": 64,
                                },
                            )

                            class Commission(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                commission_payable_amount: Optional[
                                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RatePlans.RatePlan.Commission.CommissionPayableAmount"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "CommissionPayableAmount",
                                        "type": "Element",
                                    },
                                )
                                percent: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "Percent",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )

                                class CommissionPayableAmount(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    amount: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Amount",
                                            "type": "Attribute",
                                            "min_inclusive": "0.0",
                                            "pattern": r"[0-9]*\.?[0-9]*",
                                        },
                                    )
                                    currency_code: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "CurrencyCode",
                                            "type": "Attribute",
                                            "min_length": 3,
                                            "max_length": 3,
                                        },
                                    )

                            class MealsIncluded(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                meal_plan_indicator: MealsIncludedMealPlanIndicator = (
                                    field(
                                        metadata={
                                            "name": "MealPlanIndicator",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                )
                                meal_plan_codes: MealsIncludedMealPlanCodes = field(
                                    metadata={
                                        "name": "MealPlanCodes",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )

                    class RoomRates(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        room_rate: "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RoomRates.RoomRate" = field(
                            metadata={
                                "name": "RoomRate",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class RoomRate(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            rates: "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RoomRates.RoomRate.Rates" = field(
                                metadata={
                                    "name": "Rates",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            rate_plan_code: str = field(
                                metadata={
                                    "name": "RatePlanCode",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 64,
                                }
                            )
                            room_type_code: str = field(
                                metadata={
                                    "name": "RoomTypeCode",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 8,
                                }
                            )

                            class Rates(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                rate: list[
                                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RoomRates.RoomRate.Rates.Rate"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "Rate",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class Rate(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    base: list[
                                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.RoomRates.RoomRate.Rates.Rate.Base"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "Base",
                                            "type": "Element",
                                            "min_occurs": 1,
                                        },
                                    )
                                    effective_date: str = field(
                                        metadata={
                                            "name": "EffectiveDate",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"\S+",
                                        }
                                    )
                                    expire_date: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "ExpireDate",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    expire_date_exclusive_ind: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "ExpireDateExclusiveInd",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    rate_time_unit: Optional[RateRateTimeUnit] = field(
                                        default=None,
                                        metadata={
                                            "name": "RateTimeUnit",
                                            "type": "Attribute",
                                        },
                                    )
                                    unit_multiplier: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "UnitMultiplier",
                                            "type": "Attribute",
                                            "pattern": r"[0-9]+",
                                        },
                                    )

                                    class Base(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        amount_after_tax: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "AmountAfterTax",
                                                "type": "Attribute",
                                                "min_exclusive": "0.0",
                                                "pattern": r"[0-9]*\.?[0-9]*",
                                            },
                                        )
                                        currency_code: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CurrencyCode",
                                                "type": "Attribute",
                                                "min_length": 3,
                                                "max_length": 3,
                                            },
                                        )

                    class GuestCounts(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        guest_count: list[
                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.GuestCounts.GuestCount"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "GuestCount",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class GuestCount(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            count: str = field(
                                metadata={
                                    "name": "Count",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            age: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Age",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )

                    class TimeSpan(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        start_date_window: Optional[
                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.TimeSpan.StartDateWindow"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "StartDateWindow",
                                "type": "Element",
                            },
                        )
                        start: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Start",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )
                        end: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "End",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )
                        duration: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Duration",
                                "type": "Attribute",
                                "pattern": r"P[0-9]+N",
                            },
                        )

                        class StartDateWindow(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            earliest_date: str = field(
                                metadata={
                                    "name": "EarliestDate",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"\S+",
                                }
                            )
                            latest_date: str = field(
                                metadata={
                                    "name": "LatestDate",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"\S+",
                                }
                            )

                    class Guarantee(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        guarantees_accepted: "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.Guarantee.GuaranteesAccepted" = field(
                            metadata={
                                "name": "GuaranteesAccepted",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class GuaranteesAccepted(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            guarantee_accepted: "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.Guarantee.GuaranteesAccepted.GuaranteeAccepted" = field(
                                metadata={
                                    "name": "GuaranteeAccepted",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class GuaranteeAccepted(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                payment_card: "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.Guarantee.GuaranteesAccepted.GuaranteeAccepted.PaymentCard" = field(
                                    metadata={
                                        "name": "PaymentCard",
                                        "type": "Element",
                                        "required": True,
                                    }
                                )

                                class PaymentCard(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    card_holder_name: str = field(
                                        metadata={
                                            "name": "CardHolderName",
                                            "type": "Element",
                                            "required": True,
                                            "min_length": 1,
                                            "max_length": 64,
                                        }
                                    )
                                    card_number: "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.Guarantee.GuaranteesAccepted.GuaranteeAccepted.PaymentCard.CardNumber" = field(
                                        metadata={
                                            "name": "CardNumber",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )
                                    card_code: str = field(
                                        metadata={
                                            "name": "CardCode",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[A-Z][A-Z]?",
                                        }
                                    )
                                    expire_date: str = field(
                                        metadata={
                                            "name": "ExpireDate",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[0-9][0-9][0-9][0-9]",
                                        }
                                    )

                                    class CardNumber(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        plain_text: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "PlainText",
                                                "type": "Element",
                                                "min_length": 1,
                                            },
                                        )
                                        encrypted_value: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "EncryptedValue",
                                                "type": "Attribute",
                                                "min_length": 1,
                                            },
                                        )
                                        encryption_method: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "EncryptionMethod",
                                                "type": "Attribute",
                                                "min_length": 1,
                                            },
                                        )

                    class Total(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        amount_after_tax: str = field(
                            metadata={
                                "name": "AmountAfterTax",
                                "type": "Attribute",
                                "required": True,
                                "min_inclusive": "0.0",
                                "pattern": r"[0-9]*\.?[0-9]*",
                            }
                        )
                        currency_code: str = field(
                            metadata={
                                "name": "CurrencyCode",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 3,
                                "max_length": 3,
                            }
                        )

                    class ServiceRphs(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        service_rph: list[
                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.RoomStays.RoomStay.ServiceRphs.ServiceRph"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "ServiceRPH",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class ServiceRph(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            rph: str = field(
                                metadata={
                                    "name": "RPH",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]{1,8}",
                                }
                            )

            class Services(BaseModel):
                model_config = ConfigDict(defer_build=True)
                service: list[
                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "Service",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class Service(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    service_details: "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service.ServiceDetails" = field(
                        metadata={
                            "name": "ServiceDetails",
                            "type": "Element",
                            "required": True,
                        }
                    )
                    id: str = field(
                        metadata={
                            "name": "ID",
                            "type": "Attribute",
                            "required": True,
                            "min_length": 1,
                            "max_length": 32,
                        }
                    )
                    type_value: ServiceType = field(
                        metadata={
                            "name": "Type",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    service_category_code: ServiceServiceCategoryCode = field(
                        metadata={
                            "name": "ServiceCategoryCode",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    service_inventory_code: str = field(
                        metadata={
                            "name": "ServiceInventoryCode",
                            "type": "Attribute",
                            "required": True,
                            "min_length": 1,
                            "max_length": 16,
                        }
                    )
                    service_rph: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "ServiceRPH",
                            "type": "Attribute",
                            "pattern": r"[0-9]{1,8}",
                        },
                    )
                    service_pricing_type: ServiceServicePricingType = field(
                        metadata={
                            "name": "ServicePricingType",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    inclusive: bool = field(
                        metadata={
                            "name": "Inclusive",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    quantity: str = field(
                        metadata={
                            "name": "Quantity",
                            "type": "Attribute",
                            "required": True,
                            "pattern": r"[0-9]+",
                        }
                    )

                    class ServiceDetails(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        guest_counts: Optional[
                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service.ServiceDetails.GuestCounts"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "GuestCounts",
                                "type": "Element",
                            },
                        )
                        time_span: Optional[
                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service.ServiceDetails.TimeSpan"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "TimeSpan",
                                "type": "Element",
                            },
                        )
                        comments: Optional[
                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service.ServiceDetails.Comments"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "Comments",
                                "type": "Element",
                            },
                        )
                        total: "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service.ServiceDetails.Total" = field(
                            metadata={
                                "name": "Total",
                                "type": "Element",
                                "required": True,
                            }
                        )
                        service_description: Optional[
                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service.ServiceDetails.ServiceDescription"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "ServiceDescription",
                                "type": "Element",
                            },
                        )

                        class GuestCounts(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            guest_count: list[
                                "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service.ServiceDetails.GuestCounts.GuestCount"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "GuestCount",
                                    "type": "Element",
                                    "min_occurs": 1,
                                    "max_occurs": 99,
                                },
                            )

                            class GuestCount(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                age: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "Age",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )
                                count: str = field(
                                    metadata={
                                        "name": "Count",
                                        "type": "Attribute",
                                        "required": True,
                                        "pattern": r"[0-9]+",
                                    }
                                )

                        class TimeSpan(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            start: str = field(
                                metadata={
                                    "name": "Start",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"\S+",
                                }
                            )
                            end: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "End",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )

                        class Comments(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            comment: "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service.ServiceDetails.Comments.Comment" = field(
                                metadata={
                                    "name": "Comment",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class Comment(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text: "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service.ServiceDetails.Comments.Comment.Text" = field(
                                    metadata={
                                        "name": "Text",
                                        "type": "Element",
                                        "required": True,
                                    }
                                )

                                class Text(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    text_format: TextTextFormat1 = field(
                                        metadata={
                                            "name": "TextFormat",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )

                        class Total(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            amount_after_tax: str = field(
                                metadata={
                                    "name": "AmountAfterTax",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                }
                            )
                            currency_code: str = field(
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_length": 3,
                                    "max_length": 3,
                                }
                            )

                        class ServiceDescription(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            text: "OtaHotelResNotifRq.HotelReservations.HotelReservation.Services.Service.ServiceDetails.ServiceDescription.Text" = field(
                                metadata={
                                    "name": "Text",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class Text(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                value: str = field(
                                    default="",
                                    metadata={
                                        "required": True,
                                        "min_length": 1,
                                    },
                                )
                                text_format: TextTextFormat1 = field(
                                    metadata={
                                        "name": "TextFormat",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )

            class ResGuests(BaseModel):
                model_config = ConfigDict(defer_build=True)
                res_guest: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest" = field(
                    metadata={
                        "name": "ResGuest",
                        "type": "Element",
                        "required": True,
                    }
                )

                class ResGuest(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    profiles: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles" = field(
                        metadata={
                            "name": "Profiles",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class Profiles(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        profile_info: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo" = field(
                            metadata={
                                "name": "ProfileInfo",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class ProfileInfo(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            profile: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile" = field(
                                metadata={
                                    "name": "Profile",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class Profile(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                customer: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer" = field(
                                    metadata={
                                        "name": "Customer",
                                        "type": "Element",
                                        "required": True,
                                    }
                                )

                                class Customer(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    person_name: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer.PersonName" = field(
                                        metadata={
                                            "name": "PersonName",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )
                                    telephone: list[
                                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer.Telephone"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "Telephone",
                                            "type": "Element",
                                        },
                                    )
                                    email: Optional[
                                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer.Email"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "Email",
                                            "type": "Element",
                                        },
                                    )
                                    address: Optional[
                                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer.Address"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "Address",
                                            "type": "Element",
                                        },
                                    )
                                    gender: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Gender",
                                            "type": "Attribute",
                                            "pattern": r"(Unknown|Male|Female)",
                                        },
                                    )
                                    birth_date: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "BirthDate",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    language: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Language",
                                            "type": "Attribute",
                                            "pattern": r"[a-z][a-z]",
                                        },
                                    )

                                    class PersonName(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        name_prefix: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "NamePrefix",
                                                "type": "Element",
                                                "min_length": 1,
                                                "max_length": 16,
                                            },
                                        )
                                        given_name: str = field(
                                            metadata={
                                                "name": "GivenName",
                                                "type": "Element",
                                                "required": True,
                                                "min_length": 1,
                                                "max_length": 64,
                                            }
                                        )
                                        surname: str = field(
                                            metadata={
                                                "name": "Surname",
                                                "type": "Element",
                                                "required": True,
                                                "min_length": 1,
                                                "max_length": 64,
                                            }
                                        )
                                        name_title: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "NameTitle",
                                                "type": "Element",
                                                "min_length": 1,
                                                "max_length": 16,
                                            },
                                        )

                                    class Telephone(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        phone_tech_type: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "PhoneTechType",
                                                "type": "Attribute",
                                                "pattern": r"(1|3|5)",
                                            },
                                        )
                                        phone_number: str = field(
                                            metadata={
                                                "name": "PhoneNumber",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"\+?[0-9]+",
                                            }
                                        )

                                    class Email(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        value: str = field(
                                            default="",
                                            metadata={
                                                "required": True,
                                                "pattern": r"\S+@\S+",
                                            },
                                        )
                                        remark: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Remark",
                                                "type": "Attribute",
                                                "pattern": r"newsletter:(no|yes)",
                                            },
                                        )

                                    class Address(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        address_line: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "AddressLine",
                                                "type": "Element",
                                                "min_length": 1,
                                                "max_length": 255,
                                            },
                                        )
                                        city_name: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CityName",
                                                "type": "Element",
                                                "min_length": 1,
                                                "max_length": 64,
                                            },
                                        )
                                        postal_code: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "PostalCode",
                                                "type": "Element",
                                                "min_length": 1,
                                                "max_length": 16,
                                            },
                                        )
                                        country_name: Optional[
                                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer.Address.CountryName"
                                        ] = field(
                                            default=None,
                                            metadata={
                                                "name": "CountryName",
                                                "type": "Element",
                                            },
                                        )
                                        remark: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Remark",
                                                "type": "Attribute",
                                                "pattern": r"catalog:(no|yes)",
                                            },
                                        )

                                        class CountryName(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            code: str = field(
                                                metadata={
                                                    "name": "Code",
                                                    "type": "Attribute",
                                                    "required": True,
                                                    "pattern": r"[A-Z][A-Z]",
                                                }
                                            )

            class ResGlobalInfo(BaseModel):
                model_config = ConfigDict(defer_build=True)
                comments: Optional[
                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Comments"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Comments",
                        "type": "Element",
                    },
                )
                special_requests: Optional[
                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.SpecialRequests"
                ] = field(
                    default=None,
                    metadata={
                        "name": "SpecialRequests",
                        "type": "Element",
                    },
                )
                deposit_payments: Optional[
                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.DepositPayments"
                ] = field(
                    default=None,
                    metadata={
                        "name": "DepositPayments",
                        "type": "Element",
                    },
                )
                cancel_penalties: Optional[
                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.CancelPenalties"
                ] = field(
                    default=None,
                    metadata={
                        "name": "CancelPenalties",
                        "type": "Element",
                    },
                )
                hotel_reservation_ids: Optional[
                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.HotelReservationIds"
                ] = field(
                    default=None,
                    metadata={
                        "name": "HotelReservationIDs",
                        "type": "Element",
                    },
                )
                profiles: Optional[
                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Profiles"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Profiles",
                        "type": "Element",
                    },
                )
                basic_property_info: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.BasicPropertyInfo" = field(
                    metadata={
                        "name": "BasicPropertyInfo",
                        "type": "Element",
                        "required": True,
                    }
                )

                class Comments(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    comment: list[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Comments.Comment"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "Comment",
                            "type": "Element",
                            "min_occurs": 1,
                            "max_occurs": 3,
                        },
                    )

                    class Comment(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        list_item: list[
                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Comments.Comment.ListItem"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "ListItem",
                                "type": "Element",
                            },
                        )
                        text: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Text",
                                "type": "Element",
                                "min_length": 1,
                            },
                        )
                        name: CommentName2 = field(
                            metadata={
                                "name": "Name",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

                        class ListItem(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                    "min_length": 1,
                                },
                            )
                            list_item: str = field(
                                metadata={
                                    "name": "ListItem",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            language: str = field(
                                metadata={
                                    "name": "Language",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[a-z][a-z]",
                                }
                            )

                class SpecialRequests(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    special_request: list[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.SpecialRequests.SpecialRequest"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "SpecialRequest",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )

                    class SpecialRequest(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        text: Optional[
                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.SpecialRequests.SpecialRequest.Text"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "Text",
                                "type": "Element",
                            },
                        )
                        request_code: str = field(
                            metadata={
                                "name": "RequestCode",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 16,
                            }
                        )
                        code_context: SpecialRequestCodeContext = field(
                            metadata={
                                "name": "CodeContext",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

                        class Text(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                },
                            )
                            text_format: TextTextFormat1 = field(
                                metadata={
                                    "name": "TextFormat",
                                    "type": "Attribute",
                                    "required": True,
                                }
                            )

                class DepositPayments(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    guarantee_payment: list[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "GuaranteePayment",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )

                    class GuaranteePayment(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        accepted_payments: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments" = field(
                            metadata={
                                "name": "AcceptedPayments",
                                "type": "Element",
                                "required": True,
                            }
                        )
                        amount_percent: Optional[
                            "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AmountPercent"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "AmountPercent",
                                "type": "Element",
                            },
                        )
                        start: Optional[object] = field(
                            default=None,
                            metadata={
                                "name": "Start",
                                "type": "Attribute",
                            },
                        )
                        guarantee_code: Optional[object] = field(
                            default=None,
                            metadata={
                                "name": "GuaranteeCode",
                                "type": "Attribute",
                            },
                        )

                        class AcceptedPayments(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            accepted_payment: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment" = field(
                                metadata={
                                    "name": "AcceptedPayment",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class AcceptedPayment(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                payment_card: Optional[
                                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment.PaymentCard"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "PaymentCard",
                                        "type": "Element",
                                    },
                                )
                                bank_acct: Optional[
                                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment.BankAcct"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "BankAcct",
                                        "type": "Element",
                                    },
                                )
                                voucher: Optional[
                                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment.Voucher"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "Voucher",
                                        "type": "Element",
                                    },
                                )
                                guarantee_type_code: Optional[object] = field(
                                    default=None,
                                    metadata={
                                        "name": "GuaranteeTypeCode",
                                        "type": "Attribute",
                                    },
                                )
                                guarantee_id: Optional[object] = field(
                                    default=None,
                                    metadata={
                                        "name": "GuaranteeID",
                                        "type": "Attribute",
                                    },
                                )
                                payment_transaction_type_code: Optional[object] = field(
                                    default=None,
                                    metadata={
                                        "name": "PaymentTransactionTypeCode",
                                        "type": "Attribute",
                                    },
                                )

                                class PaymentCard(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    card_holder_name: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "CardHolderName",
                                            "type": "Element",
                                            "min_length": 1,
                                            "max_length": 64,
                                        },
                                    )
                                    card_number: Optional[
                                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment.PaymentCard.CardNumber"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "CardNumber",
                                            "type": "Element",
                                        },
                                    )
                                    card_code: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "CardCode",
                                            "type": "Attribute",
                                            "pattern": r"[A-Z]{1,2}",
                                        },
                                    )
                                    expire_date: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "ExpireDate",
                                            "type": "Attribute",
                                            "pattern": r"(0[1-9]|1[0-2])[0-9][0-9]",
                                        },
                                    )

                                    class CardNumber(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        mask: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Mask",
                                                "type": "Attribute",
                                                "pattern": r"[0-9a-zA-Z]{1,32}",
                                            },
                                        )
                                        token: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Token",
                                                "type": "Attribute",
                                                "pattern": r"[0-9a-zA-Z]{1,32}",
                                            },
                                        )
                                        token_provider_id: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "TokenProviderID",
                                                "type": "Attribute",
                                                "min_length": 1,
                                            },
                                        )

                                class BankAcct(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    bank_acct_name: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "BankAcctName",
                                            "type": "Element",
                                            "min_length": 1,
                                            "max_length": 64,
                                        },
                                    )
                                    bank_acct_number: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment.BankAcct.BankAcctNumber" = field(
                                        metadata={
                                            "name": "BankAcctNumber",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )

                                    class BankAcctNumber(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        plain_text: str = field(
                                            metadata={
                                                "name": "PlainText",
                                                "type": "Element",
                                                "required": True,
                                                "pattern": r"[0-9]{1,19}",
                                            }
                                        )
                                        mask: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Mask",
                                                "type": "Attribute",
                                                "pattern": r"[0-9a-zA-Z]{1,32}",
                                            },
                                        )

                                class Voucher(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    electronic_indicator: str = field(
                                        metadata={
                                            "name": "ElectronicIndicator",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"1|true",
                                        }
                                    )
                                    identifier: str = field(
                                        metadata={
                                            "name": "Identifier",
                                            "type": "Attribute",
                                            "required": True,
                                            "min_length": 1,
                                            "max_length": 64,
                                        }
                                    )

                        class AmountPercent(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            amount: str = field(
                                metadata={
                                    "name": "Amount",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_exclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                }
                            )
                            currency_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "min_length": 3,
                                    "max_length": 3,
                                },
                            )

                class CancelPenalties(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    cancel_penalty: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.CancelPenalties.CancelPenalty" = field(
                        metadata={
                            "name": "CancelPenalty",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class CancelPenalty(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        penalty_description: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.CancelPenalties.CancelPenalty.PenaltyDescription" = field(
                            metadata={
                                "name": "PenaltyDescription",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class PenaltyDescription(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            text: str = field(
                                metadata={
                                    "name": "Text",
                                    "type": "Element",
                                    "required": True,
                                    "min_length": 1,
                                }
                            )

                class HotelReservationIds(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    hotel_reservation_id: list[
                        "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.HotelReservationIds.HotelReservationId"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "HotelReservationID",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )

                    class HotelReservationId(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        res_id_type: str = field(
                            metadata={
                                "name": "ResID_Type",
                                "type": "Attribute",
                                "required": True,
                                "pattern": r"[0-9]+",
                            }
                        )
                        res_id_value: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "ResID_Value",
                                "type": "Attribute",
                                "min_length": 1,
                                "max_length": 64,
                            },
                        )
                        res_id_source: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "ResID_Source",
                                "type": "Attribute",
                                "min_length": 1,
                                "max_length": 64,
                            },
                        )
                        res_id_source_context: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "ResID_SourceContext",
                                "type": "Attribute",
                                "min_length": 1,
                                "max_length": 64,
                            },
                        )

                class Profiles(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    profile_info: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo" = field(
                        metadata={
                            "name": "ProfileInfo",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class ProfileInfo(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        profile: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile" = field(
                            metadata={
                                "name": "Profile",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class Profile(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            company_info: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile.CompanyInfo" = field(
                                metadata={
                                    "name": "CompanyInfo",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            profile_type: ProfileProfileType = field(
                                metadata={
                                    "name": "ProfileType",
                                    "type": "Attribute",
                                    "required": True,
                                }
                            )

                            class CompanyInfo(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                company_name: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile.CompanyInfo.CompanyName" = field(
                                    metadata={
                                        "name": "CompanyName",
                                        "type": "Element",
                                        "required": True,
                                    }
                                )
                                address_info: Optional[
                                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile.CompanyInfo.AddressInfo"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "AddressInfo",
                                        "type": "Element",
                                    },
                                )
                                telephone_info: Optional[
                                    "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile.CompanyInfo.TelephoneInfo"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "TelephoneInfo",
                                        "type": "Element",
                                    },
                                )
                                email: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "Email",
                                        "type": "Element",
                                        "min_length": 1,
                                    },
                                )

                                class CompanyName(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    code: str = field(
                                        metadata={
                                            "name": "Code",
                                            "type": "Attribute",
                                            "required": True,
                                            "min_length": 1,
                                        }
                                    )
                                    code_context: str = field(
                                        metadata={
                                            "name": "CodeContext",
                                            "type": "Attribute",
                                            "required": True,
                                            "min_length": 1,
                                        }
                                    )

                                class AddressInfo(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    address_line: str = field(
                                        metadata={
                                            "name": "AddressLine",
                                            "type": "Element",
                                            "required": True,
                                            "min_length": 1,
                                            "max_length": 255,
                                        }
                                    )
                                    city_name: str = field(
                                        metadata={
                                            "name": "CityName",
                                            "type": "Element",
                                            "required": True,
                                            "min_length": 1,
                                            "max_length": 64,
                                        }
                                    )
                                    postal_code: str = field(
                                        metadata={
                                            "name": "PostalCode",
                                            "type": "Element",
                                            "required": True,
                                            "min_length": 1,
                                            "max_length": 16,
                                        }
                                    )
                                    country_name: "OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile.CompanyInfo.AddressInfo.CountryName" = field(
                                        metadata={
                                            "name": "CountryName",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )

                                    class CountryName(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        code: str = field(
                                            metadata={
                                                "name": "Code",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"[A-Z][A-Z]",
                                            }
                                        )

                                class TelephoneInfo(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    phone_tech_type: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "PhoneTechType",
                                            "type": "Attribute",
                                            "pattern": r"(1|3|5)",
                                        },
                                    )
                                    phone_number: str = field(
                                        metadata={
                                            "name": "PhoneNumber",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"\+?[0-9]+",
                                        }
                                    )

                class BasicPropertyInfo(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    hotel_code: str = field(
                        metadata={
                            "name": "HotelCode",
                            "type": "Attribute",
                            "required": True,
                            "min_length": 1,
                            "max_length": 16,
                        }
                    )
                    hotel_name: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "HotelName",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 128,
                        },
                    )


class OtaHotelResNotifRs(BaseModel):
    class Meta:
        name = "OTA_HotelResNotifRS"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    errors: Optional["OtaHotelResNotifRs.Errors"] = field(
        default=None,
        metadata={
            "name": "Errors",
            "type": "Element",
        },
    )
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaHotelResNotifRs.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    hotel_reservations: Optional["OtaHotelResNotifRs.HotelReservations"] = field(
        default=None,
        metadata={
            "name": "HotelReservations",
            "type": "Element",
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Errors(BaseModel):
        model_config = ConfigDict(defer_build=True)
        error: list["OtaHotelResNotifRs.Errors.Error"] = field(
            default_factory=list,
            metadata={
                "name": "Error",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Error(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: ErrorType = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaHotelResNotifRs.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            code: str = field(
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            record_id: str = field(
                metadata={
                    "name": "RecordID",
                    "type": "Attribute",
                    "required": True,
                    "min_length": 1,
                    "max_length": 64,
                }
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class HotelReservations(BaseModel):
        model_config = ConfigDict(defer_build=True)
        hotel_reservation: list[
            "OtaHotelResNotifRs.HotelReservations.HotelReservation"
        ] = field(
            default_factory=list,
            metadata={
                "name": "HotelReservation",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class HotelReservation(BaseModel):
            model_config = ConfigDict(defer_build=True)
            unique_id: "OtaHotelResNotifRs.HotelReservations.HotelReservation.UniqueId" = field(
                metadata={
                    "name": "UniqueID",
                    "type": "Element",
                    "required": True,
                }
            )

            class UniqueId(BaseModel):
                model_config = ConfigDict(defer_build=True)
                type_value: UniqueIdType2 = field(
                    metadata={
                        "name": "Type",
                        "type": "Attribute",
                        "required": True,
                    }
                )
                id: str = field(
                    metadata={
                        "name": "ID",
                        "type": "Attribute",
                        "required": True,
                        "min_length": 1,
                        "max_length": 32,
                    }
                )


class OtaNotifReportRq(BaseModel):
    class Meta:
        name = "OTA_NotifReportRQ"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaNotifReportRq.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    notif_details: Optional["OtaNotifReportRq.NotifDetails"] = field(
        default=None,
        metadata={
            "name": "NotifDetails",
            "type": "Element",
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaNotifReportRq.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            code: str = field(
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            record_id: str = field(
                metadata={
                    "name": "RecordID",
                    "type": "Attribute",
                    "required": True,
                    "min_length": 1,
                    "max_length": 64,
                }
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class NotifDetails(BaseModel):
        model_config = ConfigDict(defer_build=True)
        hotel_notif_report: "OtaNotifReportRq.NotifDetails.HotelNotifReport" = field(
            metadata={
                "name": "HotelNotifReport",
                "type": "Element",
                "required": True,
            }
        )

        class HotelNotifReport(BaseModel):
            model_config = ConfigDict(defer_build=True)
            hotel_reservations: "OtaNotifReportRq.NotifDetails.HotelNotifReport.HotelReservations" = field(
                metadata={
                    "name": "HotelReservations",
                    "type": "Element",
                    "required": True,
                }
            )

            class HotelReservations(BaseModel):
                model_config = ConfigDict(defer_build=True)
                hotel_reservation: list[
                    "OtaNotifReportRq.NotifDetails.HotelNotifReport.HotelReservations.HotelReservation"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "HotelReservation",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class HotelReservation(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    unique_id: "OtaNotifReportRq.NotifDetails.HotelNotifReport.HotelReservations.HotelReservation.UniqueId" = field(
                        metadata={
                            "name": "UniqueID",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class UniqueId(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        type_value: UniqueIdType2 = field(
                            metadata={
                                "name": "Type",
                                "type": "Attribute",
                                "required": True,
                            }
                        )
                        id: str = field(
                            metadata={
                                "name": "ID",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 32,
                            }
                        )


class OtaNotifReportRs(BaseModel):
    class Meta:
        name = "OTA_NotifReportRS"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    errors: Optional["OtaNotifReportRs.Errors"] = field(
        default=None,
        metadata={
            "name": "Errors",
            "type": "Element",
        },
    )
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaNotifReportRs.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Errors(BaseModel):
        model_config = ConfigDict(defer_build=True)
        error: list["OtaNotifReportRs.Errors.Error"] = field(
            default_factory=list,
            metadata={
                "name": "Error",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Error(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: ErrorType = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaNotifReportRs.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            record_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RecordID",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )


class OtaPingRs(BaseModel):
    class Meta:
        name = "OTA_PingRS"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    errors: Optional["OtaPingRs.Errors"] = field(
        default=None,
        metadata={
            "name": "Errors",
            "type": "Element",
        },
    )
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaPingRs.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    echo_data: Optional[str] = field(
        default=None,
        metadata={
            "name": "EchoData",
            "type": "Element",
            "min_length": 1,
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Errors(BaseModel):
        model_config = ConfigDict(defer_build=True)
        error: list["OtaPingRs.Errors.Error"] = field(
            default_factory=list,
            metadata={
                "name": "Error",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Error(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: ErrorType = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            status: Optional[ErrorStatus] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaPingRs.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            status: Optional[WarningStatus] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )


class OtaResRetrieveRs(BaseModel):
    class Meta:
        name = "OTA_ResRetrieveRS"
        namespace = "http://www.opentravel.org/OTA/2003/05"

    model_config = ConfigDict(defer_build=True)
    errors: Optional["OtaResRetrieveRs.Errors"] = field(
        default=None,
        metadata={
            "name": "Errors",
            "type": "Element",
        },
    )
    success: Optional[object] = field(
        default=None,
        metadata={
            "name": "Success",
            "type": "Element",
        },
    )
    warnings: Optional["OtaResRetrieveRs.Warnings"] = field(
        default=None,
        metadata={
            "name": "Warnings",
            "type": "Element",
        },
    )
    reservations_list: Optional["OtaResRetrieveRs.ReservationsList"] = field(
        default=None,
        metadata={
            "name": "ReservationsList",
            "type": "Element",
        },
    )
    version: object = field(
        metadata={
            "name": "Version",
            "type": "Attribute",
            "required": True,
        }
    )
    time_stamp: Optional[object] = field(
        default=None,
        metadata={
            "name": "TimeStamp",
            "type": "Attribute",
        },
    )

    class Errors(BaseModel):
        model_config = ConfigDict(defer_build=True)
        error: list["OtaResRetrieveRs.Errors.Error"] = field(
            default_factory=list,
            metadata={
                "name": "Error",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Error(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: ErrorType = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class Warnings(BaseModel):
        model_config = ConfigDict(defer_build=True)
        warning: list["OtaResRetrieveRs.Warnings.Warning"] = field(
            default_factory=list,
            metadata={
                "name": "Warning",
                "type": "Element",
                "min_occurs": 1,
            },
        )

        class Warning(BaseModel):
            model_config = ConfigDict(defer_build=True)
            type_value: str = field(
                metadata={
                    "name": "Type",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"[0-9]+",
                }
            )
            code: Optional[str] = field(
                default=None,
                metadata={
                    "name": "Code",
                    "type": "Attribute",
                    "pattern": r"[0-9]+",
                },
            )
            record_id: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RecordID",
                    "type": "Attribute",
                    "min_length": 1,
                    "max_length": 64,
                },
            )
            status: Optional[DefSendComplete] = field(
                default=None,
                metadata={
                    "name": "Status",
                    "type": "Attribute",
                },
            )
            content: list[object] = field(
                default_factory=list,
                metadata={
                    "type": "Wildcard",
                    "namespace": "##any",
                    "mixed": True,
                },
            )

    class ReservationsList(BaseModel):
        model_config = ConfigDict(defer_build=True)
        hotel_reservation: list[
            "OtaResRetrieveRs.ReservationsList.HotelReservation"
        ] = field(
            default_factory=list,
            metadata={
                "name": "HotelReservation",
                "type": "Element",
            },
        )

        class HotelReservation(BaseModel):
            model_config = ConfigDict(defer_build=True)
            unique_id: "OtaResRetrieveRs.ReservationsList.HotelReservation.UniqueId" = (
                field(
                    metadata={
                        "name": "UniqueID",
                        "type": "Element",
                        "required": True,
                    }
                )
            )
            room_stays: Optional[
                "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays"
            ] = field(
                default=None,
                metadata={
                    "name": "RoomStays",
                    "type": "Element",
                },
            )
            services: Optional[
                "OtaResRetrieveRs.ReservationsList.HotelReservation.Services"
            ] = field(
                default=None,
                metadata={
                    "name": "Services",
                    "type": "Element",
                },
            )
            res_guests: Optional[
                "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests"
            ] = field(
                default=None,
                metadata={
                    "name": "ResGuests",
                    "type": "Element",
                },
            )
            res_global_info: Optional[
                "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo"
            ] = field(
                default=None,
                metadata={
                    "name": "ResGlobalInfo",
                    "type": "Element",
                },
            )
            create_date_time: str = field(
                metadata={
                    "name": "CreateDateTime",
                    "type": "Attribute",
                    "required": True,
                    "pattern": r"\S+",
                }
            )
            last_modify_date_time: Optional[str] = field(
                default=None,
                metadata={
                    "name": "LastModifyDateTime",
                    "type": "Attribute",
                    "pattern": r"\S+",
                },
            )
            res_status: HotelReservationResStatus = field(
                metadata={
                    "name": "ResStatus",
                    "type": "Attribute",
                    "required": True,
                }
            )
            room_stay_reservation: Optional[str] = field(
                default=None,
                metadata={
                    "name": "RoomStayReservation",
                    "type": "Attribute",
                    "pattern": r"\S+",
                },
            )

            class UniqueId(BaseModel):
                model_config = ConfigDict(defer_build=True)
                type_value: UniqueIdType2 = field(
                    metadata={
                        "name": "Type",
                        "type": "Attribute",
                        "required": True,
                    }
                )
                id: str = field(
                    metadata={
                        "name": "ID",
                        "type": "Attribute",
                        "required": True,
                        "min_length": 1,
                        "max_length": 32,
                    }
                )

            class RoomStays(BaseModel):
                model_config = ConfigDict(defer_build=True)
                room_stay: list[
                    "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "RoomStay",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class RoomStay(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    room_types: Optional[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RoomTypes"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "RoomTypes",
                            "type": "Element",
                        },
                    )
                    rate_plans: Optional[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RatePlans"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "RatePlans",
                            "type": "Element",
                        },
                    )
                    room_rates: Optional[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RoomRates"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "RoomRates",
                            "type": "Element",
                        },
                    )
                    guest_counts: Optional[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.GuestCounts"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "GuestCounts",
                            "type": "Element",
                        },
                    )
                    time_span: "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.TimeSpan" = field(
                        metadata={
                            "name": "TimeSpan",
                            "type": "Element",
                            "required": True,
                        }
                    )
                    guarantee: Optional[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.Guarantee"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Guarantee",
                            "type": "Element",
                        },
                    )
                    total: Optional[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.Total"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "Total",
                            "type": "Element",
                        },
                    )
                    service_rphs: Optional[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.ServiceRphs"
                    ] = field(
                        default=None,
                        metadata={
                            "name": "ServiceRPHs",
                            "type": "Element",
                        },
                    )
                    room_stay_group_id: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "RoomStayGroupID",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 32,
                        },
                    )

                    class RoomTypes(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        room_type: "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RoomTypes.RoomType" = field(
                            metadata={
                                "name": "RoomType",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class RoomType(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            room_type_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "RoomTypeCode",
                                    "type": "Attribute",
                                    "min_length": 1,
                                    "max_length": 8,
                                },
                            )
                            room_classification_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "RoomClassificationCode",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )
                            room_type: Optional[RoomTypeRoomType] = field(
                                default=None,
                                metadata={
                                    "name": "RoomType",
                                    "type": "Attribute",
                                },
                            )

                    class RatePlans(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        rate_plan: "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RatePlans.RatePlan" = field(
                            metadata={
                                "name": "RatePlan",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class RatePlan(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            commission: Optional[
                                "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RatePlans.RatePlan.Commission"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "Commission",
                                    "type": "Element",
                                },
                            )
                            meals_included: Optional[
                                "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RatePlans.RatePlan.MealsIncluded"
                            ] = field(
                                default=None,
                                metadata={
                                    "name": "MealsIncluded",
                                    "type": "Element",
                                },
                            )
                            rate_plan_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "RatePlanCode",
                                    "type": "Attribute",
                                    "min_length": 1,
                                    "max_length": 64,
                                },
                            )

                            class Commission(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                commission_payable_amount: Optional[
                                    "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RatePlans.RatePlan.Commission.CommissionPayableAmount"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "CommissionPayableAmount",
                                        "type": "Element",
                                    },
                                )
                                percent: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "Percent",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )

                                class CommissionPayableAmount(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    amount: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Amount",
                                            "type": "Attribute",
                                            "min_inclusive": "0.0",
                                            "pattern": r"[0-9]*\.?[0-9]*",
                                        },
                                    )
                                    currency_code: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "CurrencyCode",
                                            "type": "Attribute",
                                            "min_length": 3,
                                            "max_length": 3,
                                        },
                                    )

                            class MealsIncluded(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                meal_plan_indicator: MealsIncludedMealPlanIndicator = (
                                    field(
                                        metadata={
                                            "name": "MealPlanIndicator",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )
                                )
                                meal_plan_codes: MealsIncludedMealPlanCodes = field(
                                    metadata={
                                        "name": "MealPlanCodes",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )

                    class RoomRates(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        room_rate: "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RoomRates.RoomRate" = field(
                            metadata={
                                "name": "RoomRate",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class RoomRate(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            rates: "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RoomRates.RoomRate.Rates" = field(
                                metadata={
                                    "name": "Rates",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            rate_plan_code: str = field(
                                metadata={
                                    "name": "RatePlanCode",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 64,
                                }
                            )
                            room_type_code: str = field(
                                metadata={
                                    "name": "RoomTypeCode",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_length": 1,
                                    "max_length": 8,
                                }
                            )

                            class Rates(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                rate: list[
                                    "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RoomRates.RoomRate.Rates.Rate"
                                ] = field(
                                    default_factory=list,
                                    metadata={
                                        "name": "Rate",
                                        "type": "Element",
                                        "min_occurs": 1,
                                    },
                                )

                                class Rate(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    base: list[
                                        "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.RoomRates.RoomRate.Rates.Rate.Base"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "Base",
                                            "type": "Element",
                                            "min_occurs": 1,
                                        },
                                    )
                                    effective_date: str = field(
                                        metadata={
                                            "name": "EffectiveDate",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"\S+",
                                        }
                                    )
                                    expire_date: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "ExpireDate",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    expire_date_exclusive_ind: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "ExpireDateExclusiveInd",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    rate_time_unit: Optional[RateRateTimeUnit] = field(
                                        default=None,
                                        metadata={
                                            "name": "RateTimeUnit",
                                            "type": "Attribute",
                                        },
                                    )
                                    unit_multiplier: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "UnitMultiplier",
                                            "type": "Attribute",
                                            "pattern": r"[0-9]+",
                                        },
                                    )

                                    class Base(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        amount_after_tax: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "AmountAfterTax",
                                                "type": "Attribute",
                                                "min_exclusive": "0.0",
                                                "pattern": r"[0-9]*\.?[0-9]*",
                                            },
                                        )
                                        currency_code: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CurrencyCode",
                                                "type": "Attribute",
                                                "min_length": 3,
                                                "max_length": 3,
                                            },
                                        )

                    class GuestCounts(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        guest_count: list[
                            "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.GuestCounts.GuestCount"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "GuestCount",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class GuestCount(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            count: str = field(
                                metadata={
                                    "name": "Count",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            age: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "Age",
                                    "type": "Attribute",
                                    "pattern": r"[0-9]+",
                                },
                            )

                    class TimeSpan(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        start_date_window: Optional[
                            "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.TimeSpan.StartDateWindow"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "StartDateWindow",
                                "type": "Element",
                            },
                        )
                        start: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Start",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )
                        end: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "End",
                                "type": "Attribute",
                                "pattern": r"\S+",
                            },
                        )
                        duration: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Duration",
                                "type": "Attribute",
                                "pattern": r"P[0-9]+N",
                            },
                        )

                        class StartDateWindow(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            earliest_date: str = field(
                                metadata={
                                    "name": "EarliestDate",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"\S+",
                                }
                            )
                            latest_date: str = field(
                                metadata={
                                    "name": "LatestDate",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"\S+",
                                }
                            )

                    class Guarantee(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        guarantees_accepted: "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.Guarantee.GuaranteesAccepted" = field(
                            metadata={
                                "name": "GuaranteesAccepted",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class GuaranteesAccepted(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            guarantee_accepted: "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.Guarantee.GuaranteesAccepted.GuaranteeAccepted" = field(
                                metadata={
                                    "name": "GuaranteeAccepted",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class GuaranteeAccepted(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                payment_card: "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.Guarantee.GuaranteesAccepted.GuaranteeAccepted.PaymentCard" = field(
                                    metadata={
                                        "name": "PaymentCard",
                                        "type": "Element",
                                        "required": True,
                                    }
                                )

                                class PaymentCard(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    card_holder_name: str = field(
                                        metadata={
                                            "name": "CardHolderName",
                                            "type": "Element",
                                            "required": True,
                                            "min_length": 1,
                                            "max_length": 64,
                                        }
                                    )
                                    card_number: "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.Guarantee.GuaranteesAccepted.GuaranteeAccepted.PaymentCard.CardNumber" = field(
                                        metadata={
                                            "name": "CardNumber",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )
                                    card_code: str = field(
                                        metadata={
                                            "name": "CardCode",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[A-Z][A-Z]?",
                                        }
                                    )
                                    expire_date: str = field(
                                        metadata={
                                            "name": "ExpireDate",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"[0-9][0-9][0-9][0-9]",
                                        }
                                    )

                                    class CardNumber(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        plain_text: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "PlainText",
                                                "type": "Element",
                                                "min_length": 1,
                                            },
                                        )
                                        encrypted_value: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "EncryptedValue",
                                                "type": "Attribute",
                                                "min_length": 1,
                                            },
                                        )
                                        encryption_method: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "EncryptionMethod",
                                                "type": "Attribute",
                                                "min_length": 1,
                                            },
                                        )

                    class Total(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        amount_after_tax: str = field(
                            metadata={
                                "name": "AmountAfterTax",
                                "type": "Attribute",
                                "required": True,
                                "min_inclusive": "0.0",
                                "pattern": r"[0-9]*\.?[0-9]*",
                            }
                        )
                        currency_code: str = field(
                            metadata={
                                "name": "CurrencyCode",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 3,
                                "max_length": 3,
                            }
                        )

                    class ServiceRphs(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        service_rph: list[
                            "OtaResRetrieveRs.ReservationsList.HotelReservation.RoomStays.RoomStay.ServiceRphs.ServiceRph"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "ServiceRPH",
                                "type": "Element",
                                "min_occurs": 1,
                            },
                        )

                        class ServiceRph(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            rph: str = field(
                                metadata={
                                    "name": "RPH",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]{1,8}",
                                }
                            )

            class Services(BaseModel):
                model_config = ConfigDict(defer_build=True)
                service: list[
                    "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service"
                ] = field(
                    default_factory=list,
                    metadata={
                        "name": "Service",
                        "type": "Element",
                        "min_occurs": 1,
                    },
                )

                class Service(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    service_details: "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service.ServiceDetails" = field(
                        metadata={
                            "name": "ServiceDetails",
                            "type": "Element",
                            "required": True,
                        }
                    )
                    id: str = field(
                        metadata={
                            "name": "ID",
                            "type": "Attribute",
                            "required": True,
                            "min_length": 1,
                            "max_length": 32,
                        }
                    )
                    type_value: ServiceType = field(
                        metadata={
                            "name": "Type",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    service_category_code: ServiceServiceCategoryCode = field(
                        metadata={
                            "name": "ServiceCategoryCode",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    service_inventory_code: str = field(
                        metadata={
                            "name": "ServiceInventoryCode",
                            "type": "Attribute",
                            "required": True,
                            "min_length": 1,
                            "max_length": 16,
                        }
                    )
                    service_rph: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "ServiceRPH",
                            "type": "Attribute",
                            "pattern": r"[0-9]{1,8}",
                        },
                    )
                    service_pricing_type: ServiceServicePricingType = field(
                        metadata={
                            "name": "ServicePricingType",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    inclusive: bool = field(
                        metadata={
                            "name": "Inclusive",
                            "type": "Attribute",
                            "required": True,
                        }
                    )
                    quantity: str = field(
                        metadata={
                            "name": "Quantity",
                            "type": "Attribute",
                            "required": True,
                            "pattern": r"[0-9]+",
                        }
                    )

                    class ServiceDetails(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        guest_counts: Optional[
                            "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service.ServiceDetails.GuestCounts"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "GuestCounts",
                                "type": "Element",
                            },
                        )
                        time_span: Optional[
                            "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service.ServiceDetails.TimeSpan"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "TimeSpan",
                                "type": "Element",
                            },
                        )
                        comments: Optional[
                            "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service.ServiceDetails.Comments"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "Comments",
                                "type": "Element",
                            },
                        )
                        total: "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service.ServiceDetails.Total" = field(
                            metadata={
                                "name": "Total",
                                "type": "Element",
                                "required": True,
                            }
                        )
                        service_description: Optional[
                            "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service.ServiceDetails.ServiceDescription"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "ServiceDescription",
                                "type": "Element",
                            },
                        )

                        class GuestCounts(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            guest_count: list[
                                "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service.ServiceDetails.GuestCounts.GuestCount"
                            ] = field(
                                default_factory=list,
                                metadata={
                                    "name": "GuestCount",
                                    "type": "Element",
                                    "min_occurs": 1,
                                    "max_occurs": 99,
                                },
                            )

                            class GuestCount(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                age: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "Age",
                                        "type": "Attribute",
                                        "pattern": r"[0-9]+",
                                    },
                                )
                                count: str = field(
                                    metadata={
                                        "name": "Count",
                                        "type": "Attribute",
                                        "required": True,
                                        "pattern": r"[0-9]+",
                                    }
                                )

                        class TimeSpan(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            start: str = field(
                                metadata={
                                    "name": "Start",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"\S+",
                                }
                            )
                            end: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "End",
                                    "type": "Attribute",
                                    "pattern": r"\S+",
                                },
                            )

                        class Comments(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            comment: "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service.ServiceDetails.Comments.Comment" = field(
                                metadata={
                                    "name": "Comment",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class Comment(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                text: "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service.ServiceDetails.Comments.Comment.Text" = field(
                                    metadata={
                                        "name": "Text",
                                        "type": "Element",
                                        "required": True,
                                    }
                                )

                                class Text(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    text_format: TextTextFormat1 = field(
                                        metadata={
                                            "name": "TextFormat",
                                            "type": "Attribute",
                                            "required": True,
                                        }
                                    )

                        class Total(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            amount_after_tax: str = field(
                                metadata={
                                    "name": "AmountAfterTax",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_inclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                }
                            )
                            currency_code: str = field(
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_length": 3,
                                    "max_length": 3,
                                }
                            )

                        class ServiceDescription(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            text: "OtaResRetrieveRs.ReservationsList.HotelReservation.Services.Service.ServiceDetails.ServiceDescription.Text" = field(
                                metadata={
                                    "name": "Text",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class Text(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                value: str = field(
                                    default="",
                                    metadata={
                                        "required": True,
                                        "min_length": 1,
                                    },
                                )
                                text_format: TextTextFormat1 = field(
                                    metadata={
                                        "name": "TextFormat",
                                        "type": "Attribute",
                                        "required": True,
                                    }
                                )

            class ResGuests(BaseModel):
                model_config = ConfigDict(defer_build=True)
                res_guest: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest" = field(
                    metadata={
                        "name": "ResGuest",
                        "type": "Element",
                        "required": True,
                    }
                )

                class ResGuest(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    profiles: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles" = field(
                        metadata={
                            "name": "Profiles",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class Profiles(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        profile_info: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo" = field(
                            metadata={
                                "name": "ProfileInfo",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class ProfileInfo(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            profile: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile" = field(
                                metadata={
                                    "name": "Profile",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class Profile(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                customer: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer" = field(
                                    metadata={
                                        "name": "Customer",
                                        "type": "Element",
                                        "required": True,
                                    }
                                )

                                class Customer(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    person_name: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer.PersonName" = field(
                                        metadata={
                                            "name": "PersonName",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )
                                    telephone: list[
                                        "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer.Telephone"
                                    ] = field(
                                        default_factory=list,
                                        metadata={
                                            "name": "Telephone",
                                            "type": "Element",
                                        },
                                    )
                                    email: Optional[
                                        "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer.Email"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "Email",
                                            "type": "Element",
                                        },
                                    )
                                    address: Optional[
                                        "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer.Address"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "Address",
                                            "type": "Element",
                                        },
                                    )
                                    gender: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Gender",
                                            "type": "Attribute",
                                            "pattern": r"(Unknown|Male|Female)",
                                        },
                                    )
                                    birth_date: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "BirthDate",
                                            "type": "Attribute",
                                            "pattern": r"\S+",
                                        },
                                    )
                                    language: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "Language",
                                            "type": "Attribute",
                                            "pattern": r"[a-z][a-z]",
                                        },
                                    )

                                    class PersonName(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        name_prefix: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "NamePrefix",
                                                "type": "Element",
                                                "min_length": 1,
                                                "max_length": 16,
                                            },
                                        )
                                        given_name: str = field(
                                            metadata={
                                                "name": "GivenName",
                                                "type": "Element",
                                                "required": True,
                                                "min_length": 1,
                                                "max_length": 64,
                                            }
                                        )
                                        surname: str = field(
                                            metadata={
                                                "name": "Surname",
                                                "type": "Element",
                                                "required": True,
                                                "min_length": 1,
                                                "max_length": 64,
                                            }
                                        )
                                        name_title: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "NameTitle",
                                                "type": "Element",
                                                "min_length": 1,
                                                "max_length": 16,
                                            },
                                        )

                                    class Telephone(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        phone_tech_type: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "PhoneTechType",
                                                "type": "Attribute",
                                                "pattern": r"(1|3|5)",
                                            },
                                        )
                                        phone_number: str = field(
                                            metadata={
                                                "name": "PhoneNumber",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"\+?[0-9]+",
                                            }
                                        )

                                    class Email(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        value: str = field(
                                            default="",
                                            metadata={
                                                "required": True,
                                                "pattern": r"\S+@\S+",
                                            },
                                        )
                                        remark: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Remark",
                                                "type": "Attribute",
                                                "pattern": r"newsletter:(no|yes)",
                                            },
                                        )

                                    class Address(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        address_line: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "AddressLine",
                                                "type": "Element",
                                                "min_length": 1,
                                                "max_length": 255,
                                            },
                                        )
                                        city_name: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "CityName",
                                                "type": "Element",
                                                "min_length": 1,
                                                "max_length": 64,
                                            },
                                        )
                                        postal_code: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "PostalCode",
                                                "type": "Element",
                                                "min_length": 1,
                                                "max_length": 16,
                                            },
                                        )
                                        country_name: Optional[
                                            "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer.Address.CountryName"
                                        ] = field(
                                            default=None,
                                            metadata={
                                                "name": "CountryName",
                                                "type": "Element",
                                            },
                                        )
                                        remark: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Remark",
                                                "type": "Attribute",
                                                "pattern": r"catalog:(no|yes)",
                                            },
                                        )

                                        class CountryName(BaseModel):
                                            model_config = ConfigDict(defer_build=True)
                                            code: str = field(
                                                metadata={
                                                    "name": "Code",
                                                    "type": "Attribute",
                                                    "required": True,
                                                    "pattern": r"[A-Z][A-Z]",
                                                }
                                            )

            class ResGlobalInfo(BaseModel):
                model_config = ConfigDict(defer_build=True)
                comments: Optional[
                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Comments"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Comments",
                        "type": "Element",
                    },
                )
                special_requests: Optional[
                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.SpecialRequests"
                ] = field(
                    default=None,
                    metadata={
                        "name": "SpecialRequests",
                        "type": "Element",
                    },
                )
                deposit_payments: Optional[
                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.DepositPayments"
                ] = field(
                    default=None,
                    metadata={
                        "name": "DepositPayments",
                        "type": "Element",
                    },
                )
                cancel_penalties: Optional[
                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.CancelPenalties"
                ] = field(
                    default=None,
                    metadata={
                        "name": "CancelPenalties",
                        "type": "Element",
                    },
                )
                hotel_reservation_ids: Optional[
                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.HotelReservationIds"
                ] = field(
                    default=None,
                    metadata={
                        "name": "HotelReservationIDs",
                        "type": "Element",
                    },
                )
                profiles: Optional[
                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Profiles"
                ] = field(
                    default=None,
                    metadata={
                        "name": "Profiles",
                        "type": "Element",
                    },
                )
                basic_property_info: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.BasicPropertyInfo" = field(
                    metadata={
                        "name": "BasicPropertyInfo",
                        "type": "Element",
                        "required": True,
                    }
                )

                class Comments(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    comment: list[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Comments.Comment"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "Comment",
                            "type": "Element",
                            "min_occurs": 1,
                            "max_occurs": 3,
                        },
                    )

                    class Comment(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        list_item: list[
                            "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Comments.Comment.ListItem"
                        ] = field(
                            default_factory=list,
                            metadata={
                                "name": "ListItem",
                                "type": "Element",
                            },
                        )
                        text: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "Text",
                                "type": "Element",
                                "min_length": 1,
                            },
                        )
                        name: CommentName2 = field(
                            metadata={
                                "name": "Name",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

                        class ListItem(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                    "min_length": 1,
                                },
                            )
                            list_item: str = field(
                                metadata={
                                    "name": "ListItem",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[0-9]+",
                                }
                            )
                            language: str = field(
                                metadata={
                                    "name": "Language",
                                    "type": "Attribute",
                                    "required": True,
                                    "pattern": r"[a-z][a-z]",
                                }
                            )

                class SpecialRequests(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    special_request: list[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.SpecialRequests.SpecialRequest"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "SpecialRequest",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )

                    class SpecialRequest(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        text: Optional[
                            "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.SpecialRequests.SpecialRequest.Text"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "Text",
                                "type": "Element",
                            },
                        )
                        request_code: str = field(
                            metadata={
                                "name": "RequestCode",
                                "type": "Attribute",
                                "required": True,
                                "min_length": 1,
                                "max_length": 16,
                            }
                        )
                        code_context: SpecialRequestCodeContext = field(
                            metadata={
                                "name": "CodeContext",
                                "type": "Attribute",
                                "required": True,
                            }
                        )

                        class Text(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            value: str = field(
                                default="",
                                metadata={
                                    "required": True,
                                },
                            )
                            text_format: TextTextFormat1 = field(
                                metadata={
                                    "name": "TextFormat",
                                    "type": "Attribute",
                                    "required": True,
                                }
                            )

                class DepositPayments(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    guarantee_payment: list[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "GuaranteePayment",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )

                    class GuaranteePayment(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        accepted_payments: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments" = field(
                            metadata={
                                "name": "AcceptedPayments",
                                "type": "Element",
                                "required": True,
                            }
                        )
                        amount_percent: Optional[
                            "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AmountPercent"
                        ] = field(
                            default=None,
                            metadata={
                                "name": "AmountPercent",
                                "type": "Element",
                            },
                        )
                        start: Optional[object] = field(
                            default=None,
                            metadata={
                                "name": "Start",
                                "type": "Attribute",
                            },
                        )
                        guarantee_code: Optional[object] = field(
                            default=None,
                            metadata={
                                "name": "GuaranteeCode",
                                "type": "Attribute",
                            },
                        )

                        class AcceptedPayments(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            accepted_payment: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment" = field(
                                metadata={
                                    "name": "AcceptedPayment",
                                    "type": "Element",
                                    "required": True,
                                }
                            )

                            class AcceptedPayment(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                payment_card: Optional[
                                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment.PaymentCard"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "PaymentCard",
                                        "type": "Element",
                                    },
                                )
                                bank_acct: Optional[
                                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment.BankAcct"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "BankAcct",
                                        "type": "Element",
                                    },
                                )
                                voucher: Optional[
                                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment.Voucher"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "Voucher",
                                        "type": "Element",
                                    },
                                )
                                guarantee_type_code: Optional[object] = field(
                                    default=None,
                                    metadata={
                                        "name": "GuaranteeTypeCode",
                                        "type": "Attribute",
                                    },
                                )
                                guarantee_id: Optional[object] = field(
                                    default=None,
                                    metadata={
                                        "name": "GuaranteeID",
                                        "type": "Attribute",
                                    },
                                )
                                payment_transaction_type_code: Optional[object] = field(
                                    default=None,
                                    metadata={
                                        "name": "PaymentTransactionTypeCode",
                                        "type": "Attribute",
                                    },
                                )

                                class PaymentCard(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    card_holder_name: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "CardHolderName",
                                            "type": "Element",
                                            "min_length": 1,
                                            "max_length": 64,
                                        },
                                    )
                                    card_number: Optional[
                                        "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment.PaymentCard.CardNumber"
                                    ] = field(
                                        default=None,
                                        metadata={
                                            "name": "CardNumber",
                                            "type": "Element",
                                        },
                                    )
                                    card_code: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "CardCode",
                                            "type": "Attribute",
                                            "pattern": r"[A-Z]{1,2}",
                                        },
                                    )
                                    expire_date: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "ExpireDate",
                                            "type": "Attribute",
                                            "pattern": r"(0[1-9]|1[0-2])[0-9][0-9]",
                                        },
                                    )

                                    class CardNumber(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        mask: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Mask",
                                                "type": "Attribute",
                                                "pattern": r"[0-9a-zA-Z]{1,32}",
                                            },
                                        )
                                        token: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Token",
                                                "type": "Attribute",
                                                "pattern": r"[0-9a-zA-Z]{1,32}",
                                            },
                                        )
                                        token_provider_id: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "TokenProviderID",
                                                "type": "Attribute",
                                                "min_length": 1,
                                            },
                                        )

                                class BankAcct(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    bank_acct_name: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "BankAcctName",
                                            "type": "Element",
                                            "min_length": 1,
                                            "max_length": 64,
                                        },
                                    )
                                    bank_acct_number: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.DepositPayments.GuaranteePayment.AcceptedPayments.AcceptedPayment.BankAcct.BankAcctNumber" = field(
                                        metadata={
                                            "name": "BankAcctNumber",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )

                                    class BankAcctNumber(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        plain_text: str = field(
                                            metadata={
                                                "name": "PlainText",
                                                "type": "Element",
                                                "required": True,
                                                "pattern": r"[0-9]{1,19}",
                                            }
                                        )
                                        mask: Optional[str] = field(
                                            default=None,
                                            metadata={
                                                "name": "Mask",
                                                "type": "Attribute",
                                                "pattern": r"[0-9a-zA-Z]{1,32}",
                                            },
                                        )

                                class Voucher(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    electronic_indicator: str = field(
                                        metadata={
                                            "name": "ElectronicIndicator",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"1|true",
                                        }
                                    )
                                    identifier: str = field(
                                        metadata={
                                            "name": "Identifier",
                                            "type": "Attribute",
                                            "required": True,
                                            "min_length": 1,
                                            "max_length": 64,
                                        }
                                    )

                        class AmountPercent(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            amount: str = field(
                                metadata={
                                    "name": "Amount",
                                    "type": "Attribute",
                                    "required": True,
                                    "min_exclusive": "0.0",
                                    "pattern": r"[0-9]*\.?[0-9]*",
                                }
                            )
                            currency_code: Optional[str] = field(
                                default=None,
                                metadata={
                                    "name": "CurrencyCode",
                                    "type": "Attribute",
                                    "min_length": 3,
                                    "max_length": 3,
                                },
                            )

                class CancelPenalties(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    cancel_penalty: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.CancelPenalties.CancelPenalty" = field(
                        metadata={
                            "name": "CancelPenalty",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class CancelPenalty(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        penalty_description: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.CancelPenalties.CancelPenalty.PenaltyDescription" = field(
                            metadata={
                                "name": "PenaltyDescription",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class PenaltyDescription(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            text: str = field(
                                metadata={
                                    "name": "Text",
                                    "type": "Element",
                                    "required": True,
                                    "min_length": 1,
                                }
                            )

                class HotelReservationIds(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    hotel_reservation_id: list[
                        "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.HotelReservationIds.HotelReservationId"
                    ] = field(
                        default_factory=list,
                        metadata={
                            "name": "HotelReservationID",
                            "type": "Element",
                            "min_occurs": 1,
                        },
                    )

                    class HotelReservationId(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        res_id_type: str = field(
                            metadata={
                                "name": "ResID_Type",
                                "type": "Attribute",
                                "required": True,
                                "pattern": r"[0-9]+",
                            }
                        )
                        res_id_value: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "ResID_Value",
                                "type": "Attribute",
                                "min_length": 1,
                                "max_length": 64,
                            },
                        )
                        res_id_source: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "ResID_Source",
                                "type": "Attribute",
                                "min_length": 1,
                                "max_length": 64,
                            },
                        )
                        res_id_source_context: Optional[str] = field(
                            default=None,
                            metadata={
                                "name": "ResID_SourceContext",
                                "type": "Attribute",
                                "min_length": 1,
                                "max_length": 64,
                            },
                        )

                class Profiles(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    profile_info: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo" = field(
                        metadata={
                            "name": "ProfileInfo",
                            "type": "Element",
                            "required": True,
                        }
                    )

                    class ProfileInfo(BaseModel):
                        model_config = ConfigDict(defer_build=True)
                        profile: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile" = field(
                            metadata={
                                "name": "Profile",
                                "type": "Element",
                                "required": True,
                            }
                        )

                        class Profile(BaseModel):
                            model_config = ConfigDict(defer_build=True)
                            company_info: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile.CompanyInfo" = field(
                                metadata={
                                    "name": "CompanyInfo",
                                    "type": "Element",
                                    "required": True,
                                }
                            )
                            profile_type: ProfileProfileType = field(
                                metadata={
                                    "name": "ProfileType",
                                    "type": "Attribute",
                                    "required": True,
                                }
                            )

                            class CompanyInfo(BaseModel):
                                model_config = ConfigDict(defer_build=True)
                                company_name: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile.CompanyInfo.CompanyName" = field(
                                    metadata={
                                        "name": "CompanyName",
                                        "type": "Element",
                                        "required": True,
                                    }
                                )
                                address_info: Optional[
                                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile.CompanyInfo.AddressInfo"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "AddressInfo",
                                        "type": "Element",
                                    },
                                )
                                telephone_info: Optional[
                                    "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile.CompanyInfo.TelephoneInfo"
                                ] = field(
                                    default=None,
                                    metadata={
                                        "name": "TelephoneInfo",
                                        "type": "Element",
                                    },
                                )
                                email: Optional[str] = field(
                                    default=None,
                                    metadata={
                                        "name": "Email",
                                        "type": "Element",
                                        "min_length": 1,
                                    },
                                )

                                class CompanyName(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    value: str = field(
                                        default="",
                                        metadata={
                                            "required": True,
                                            "min_length": 1,
                                        },
                                    )
                                    code: str = field(
                                        metadata={
                                            "name": "Code",
                                            "type": "Attribute",
                                            "required": True,
                                            "min_length": 1,
                                        }
                                    )
                                    code_context: str = field(
                                        metadata={
                                            "name": "CodeContext",
                                            "type": "Attribute",
                                            "required": True,
                                            "min_length": 1,
                                        }
                                    )

                                class AddressInfo(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    address_line: str = field(
                                        metadata={
                                            "name": "AddressLine",
                                            "type": "Element",
                                            "required": True,
                                            "min_length": 1,
                                            "max_length": 255,
                                        }
                                    )
                                    city_name: str = field(
                                        metadata={
                                            "name": "CityName",
                                            "type": "Element",
                                            "required": True,
                                            "min_length": 1,
                                            "max_length": 64,
                                        }
                                    )
                                    postal_code: str = field(
                                        metadata={
                                            "name": "PostalCode",
                                            "type": "Element",
                                            "required": True,
                                            "min_length": 1,
                                            "max_length": 16,
                                        }
                                    )
                                    country_name: "OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.Profiles.ProfileInfo.Profile.CompanyInfo.AddressInfo.CountryName" = field(
                                        metadata={
                                            "name": "CountryName",
                                            "type": "Element",
                                            "required": True,
                                        }
                                    )

                                    class CountryName(BaseModel):
                                        model_config = ConfigDict(defer_build=True)
                                        code: str = field(
                                            metadata={
                                                "name": "Code",
                                                "type": "Attribute",
                                                "required": True,
                                                "pattern": r"[A-Z][A-Z]",
                                            }
                                        )

                                class TelephoneInfo(BaseModel):
                                    model_config = ConfigDict(defer_build=True)
                                    phone_tech_type: Optional[str] = field(
                                        default=None,
                                        metadata={
                                            "name": "PhoneTechType",
                                            "type": "Attribute",
                                            "pattern": r"(1|3|5)",
                                        },
                                    )
                                    phone_number: str = field(
                                        metadata={
                                            "name": "PhoneNumber",
                                            "type": "Attribute",
                                            "required": True,
                                            "pattern": r"\+?[0-9]+",
                                        }
                                    )

                class BasicPropertyInfo(BaseModel):
                    model_config = ConfigDict(defer_build=True)
                    hotel_code: str = field(
                        metadata={
                            "name": "HotelCode",
                            "type": "Attribute",
                            "required": True,
                            "min_length": 1,
                            "max_length": 16,
                        }
                    )
                    hotel_name: Optional[str] = field(
                        default=None,
                        metadata={
                            "name": "HotelName",
                            "type": "Attribute",
                            "min_length": 1,
                            "max_length": 128,
                        },
                    )
