# This file is auto-generated by PrototypeX filter generator.
# Do not edit manually - changes will be overwritten.
# Regenerate using: python -m scripts.gen_filters gen

from __future__ import annotations

import datetime
import typing as t

from audex.entity.doctor import Doctor
from audex.filters import FieldFilter
from audex.filters import Filter
from audex.filters import FilterBuilder
from audex.filters import StringBackedFieldFilter
from audex.filters import StringFieldFilter
from audex.valueobj.common.auth import HashedPassword
from audex.valueobj.common.email import Email
from audex.valueobj.common.phone import CNPhone


class DoctorFilterBuilder(FilterBuilder[Doctor]):
    """Doctor filter builder with full type hints and IDE support.

    This class is auto-generated. Do not edit manually.
    """

    class _IdField(StringFieldFilter):
        """Chainable id filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("id", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: str) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: str) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: str) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: str) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: str) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: str) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[str]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[str]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(self, value1: str, value2: str) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

        def contains(self, value: str) -> DoctorFilterBuilder:
            super().contains(value)
            return self._parent_builder

        def startswith(self, value: str) -> DoctorFilterBuilder:
            super().startswith(value)
            return self._parent_builder

        def endswith(self, value: str) -> DoctorFilterBuilder:
            super().endswith(value)
            return self._parent_builder

    class _CreatedAtField(FieldFilter[datetime.datetime]):
        """Chainable created_at filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("created_at", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: datetime.datetime) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: datetime.datetime) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: datetime.datetime) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: datetime.datetime) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: datetime.datetime) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: datetime.datetime) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[datetime.datetime]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[datetime.datetime]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(
            self, value1: datetime.datetime, value2: datetime.datetime
        ) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

    class _UpdatedAtField(FieldFilter[datetime.datetime | None]):
        """Chainable updated_at filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("updated_at", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: datetime.datetime | None) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: datetime.datetime | None) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: datetime.datetime | None) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: datetime.datetime | None) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: datetime.datetime | None) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: datetime.datetime | None) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[datetime.datetime | None]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[datetime.datetime | None]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(
            self, value1: datetime.datetime | None, value2: datetime.datetime | None
        ) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

    class _EidField(StringFieldFilter):
        """Chainable eid filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("eid", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: str) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: str) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: str) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: str) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: str) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: str) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[str]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[str]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(self, value1: str, value2: str) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

        def contains(self, value: str) -> DoctorFilterBuilder:
            super().contains(value)
            return self._parent_builder

        def startswith(self, value: str) -> DoctorFilterBuilder:
            super().startswith(value)
            return self._parent_builder

        def endswith(self, value: str) -> DoctorFilterBuilder:
            super().endswith(value)
            return self._parent_builder

    class _PasswordHashField(StringBackedFieldFilter[HashedPassword]):
        """Chainable password_hash filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("password_hash", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: HashedPassword) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: HashedPassword) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: HashedPassword) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: HashedPassword) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: HashedPassword) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: HashedPassword) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[HashedPassword]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[HashedPassword]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(self, value1: HashedPassword, value2: HashedPassword) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

        def contains(self, value: str) -> DoctorFilterBuilder:
            super().contains(value)
            return self._parent_builder

        def startswith(self, value: str) -> DoctorFilterBuilder:
            super().startswith(value)
            return self._parent_builder

        def endswith(self, value: str) -> DoctorFilterBuilder:
            super().endswith(value)
            return self._parent_builder

    class _NameField(StringFieldFilter):
        """Chainable name filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("name", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: str) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: str) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: str) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: str) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: str) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: str) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[str]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[str]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(self, value1: str, value2: str) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

        def contains(self, value: str) -> DoctorFilterBuilder:
            super().contains(value)
            return self._parent_builder

        def startswith(self, value: str) -> DoctorFilterBuilder:
            super().startswith(value)
            return self._parent_builder

        def endswith(self, value: str) -> DoctorFilterBuilder:
            super().endswith(value)
            return self._parent_builder

    class _DepartmentField(StringFieldFilter):
        """Chainable department filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("department", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: str | None) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: str | None) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: str | None) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: str | None) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: str | None) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: str | None) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[str | None]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[str | None]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(self, value1: str | None, value2: str | None) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

        def contains(self, value: str) -> DoctorFilterBuilder:
            super().contains(value)
            return self._parent_builder

        def startswith(self, value: str) -> DoctorFilterBuilder:
            super().startswith(value)
            return self._parent_builder

        def endswith(self, value: str) -> DoctorFilterBuilder:
            super().endswith(value)
            return self._parent_builder

    class _TitleField(StringFieldFilter):
        """Chainable title filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("title", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: str | None) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: str | None) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: str | None) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: str | None) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: str | None) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: str | None) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[str | None]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[str | None]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(self, value1: str | None, value2: str | None) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

        def contains(self, value: str) -> DoctorFilterBuilder:
            super().contains(value)
            return self._parent_builder

        def startswith(self, value: str) -> DoctorFilterBuilder:
            super().startswith(value)
            return self._parent_builder

        def endswith(self, value: str) -> DoctorFilterBuilder:
            super().endswith(value)
            return self._parent_builder

    class _HospitalField(StringFieldFilter):
        """Chainable hospital filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("hospital", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: str | None) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: str | None) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: str | None) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: str | None) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: str | None) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: str | None) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[str | None]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[str | None]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(self, value1: str | None, value2: str | None) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

        def contains(self, value: str) -> DoctorFilterBuilder:
            super().contains(value)
            return self._parent_builder

        def startswith(self, value: str) -> DoctorFilterBuilder:
            super().startswith(value)
            return self._parent_builder

        def endswith(self, value: str) -> DoctorFilterBuilder:
            super().endswith(value)
            return self._parent_builder

    class _PhoneField(StringFieldFilter):
        """Chainable phone filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("phone", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: CNPhone | None) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: CNPhone | None) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: CNPhone | None) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: CNPhone | None) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: CNPhone | None) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: CNPhone | None) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[CNPhone | None]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[CNPhone | None]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(self, value1: CNPhone | None, value2: CNPhone | None) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

        def contains(self, value: str) -> DoctorFilterBuilder:
            super().contains(value)
            return self._parent_builder

        def startswith(self, value: str) -> DoctorFilterBuilder:
            super().startswith(value)
            return self._parent_builder

        def endswith(self, value: str) -> DoctorFilterBuilder:
            super().endswith(value)
            return self._parent_builder

    class _EmailField(StringBackedFieldFilter[Email | None]):
        """Chainable email filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("email", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: Email | None) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: Email | None) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: Email | None) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: Email | None) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: Email | None) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: Email | None) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[Email | None]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[Email | None]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(self, value1: Email | None, value2: Email | None) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

        def contains(self, value: str) -> DoctorFilterBuilder:
            super().contains(value)
            return self._parent_builder

        def startswith(self, value: str) -> DoctorFilterBuilder:
            super().startswith(value)
            return self._parent_builder

        def endswith(self, value: str) -> DoctorFilterBuilder:
            super().endswith(value)
            return self._parent_builder

    class _IsActiveField(FieldFilter[bool]):
        """Chainable is_active filter with type-safe operations."""

        def __init__(self, builder: DoctorFilterBuilder) -> None:
            super().__init__("is_active", object.__getattribute__(builder, "_filter"))
            self._parent_builder = builder

        def eq(self, value: bool) -> DoctorFilterBuilder:
            super().eq(value)
            return self._parent_builder

        def ne(self, value: bool) -> DoctorFilterBuilder:
            super().ne(value)
            return self._parent_builder

        def gt(self, value: bool) -> DoctorFilterBuilder:
            super().gt(value)
            return self._parent_builder

        def lt(self, value: bool) -> DoctorFilterBuilder:
            super().lt(value)
            return self._parent_builder

        def gte(self, value: bool) -> DoctorFilterBuilder:
            super().gte(value)
            return self._parent_builder

        def lte(self, value: bool) -> DoctorFilterBuilder:
            super().lte(value)
            return self._parent_builder

        def in_(self, values: t.Sequence[bool]) -> DoctorFilterBuilder:
            super().in_(values)
            return self._parent_builder

        def nin(self, values: t.Sequence[bool]) -> DoctorFilterBuilder:
            super().nin(values)
            return self._parent_builder

        def between(self, value1: bool, value2: bool) -> DoctorFilterBuilder:
            super().between(value1, value2)
            return self._parent_builder

        def is_null(self) -> DoctorFilterBuilder:
            super().is_null()
            return self._parent_builder

        def is_not_null(self) -> DoctorFilterBuilder:
            super().is_not_null()
            return self._parent_builder

        def asc(self) -> DoctorFilterBuilder:
            super().asc()
            return self._parent_builder

        def desc(self) -> DoctorFilterBuilder:
            super().desc()
            return self._parent_builder

    def and_(self, *filters: Filter) -> Filter:
        """Combine with other filters using AND logic.

        Args:
            *filters: Other filters to combine with AND.

        Returns:
            Combined filter with AND logic.

        Example:
            ```python
            # username = 'john' AND email = 'john@ex.com'
            filter = (
                doctor_filter()
                .username.eq("john")
                .and_(doctor_filter().email.eq("john@ex.com"))
            )
            ```
        """
        return object.__getattribute__(self, "_filter").and_(*filters)

    def or_(self, *filters: Filter) -> Filter:
        """Combine with other filters using OR logic.

        Args:
            *filters: Other filters to combine with OR.

        Returns:
            Combined filter with OR logic.

        Example:
            ```python
            # username = 'john' OR email = 'john@ex.com'
            filter = (
                doctor_filter()
                .username.eq("john")
                .or_(doctor_filter().email.eq("john@ex.com"))
            )
            ```
        """
        return object.__getattribute__(self, "_filter").or_(*filters)

    def not_(self) -> Filter:
        """Negate the current filter.

        Returns:
            Negated filter.

        Example:
            ```python
            # NOT (username = 'john')
            filter = doctor_filter().username.eq("john").not_()
            ```
        """
        return object.__getattribute__(self, "_filter").not_()

    # Field properties

    @property
    def id(self) -> _IdField:
        """Filter by id field."""
        return self._IdField(self)

    @property
    def created_at(self) -> _CreatedAtField:
        """Filter by created_at field."""
        return self._CreatedAtField(self)

    @property
    def updated_at(self) -> _UpdatedAtField:
        """Filter by updated_at field."""
        return self._UpdatedAtField(self)

    @property
    def eid(self) -> _EidField:
        """Filter by eid field."""
        return self._EidField(self)

    @property
    def password_hash(self) -> _PasswordHashField:
        """Filter by password_hash field."""
        return self._PasswordHashField(self)

    @property
    def name(self) -> _NameField:
        """Filter by name field."""
        return self._NameField(self)

    @property
    def department(self) -> _DepartmentField:
        """Filter by department field."""
        return self._DepartmentField(self)

    @property
    def title(self) -> _TitleField:
        """Filter by title field."""
        return self._TitleField(self)

    @property
    def hospital(self) -> _HospitalField:
        """Filter by hospital field."""
        return self._HospitalField(self)

    @property
    def phone(self) -> _PhoneField:
        """Filter by phone field."""
        return self._PhoneField(self)

    @property
    def email(self) -> _EmailField:
        """Filter by email field."""
        return self._EmailField(self)

    @property
    def is_active(self) -> _IsActiveField:
        """Filter by is_active field."""
        return self._IsActiveField(self)


def doctor_filter() -> DoctorFilterBuilder:
    """Create a Doctor filter builder with full type safety.

    Returns:
        A DoctorFilterBuilder instance with full IDE support and chainable fields.

    Example:
        ```python
        # AND conditions (chained)
        filter = (
            doctor_filter()
            .field1.eq(value1)
            .field2.contains(value2)
        )

        # OR conditions
        filter = doctor_filter().field1.eq(
            value1
        ) | doctor_filter().field2.eq(value2)
        ```
    """
    return DoctorFilterBuilder(Doctor)
