type_bridge.typed

typed

Owner-aware typed-query references backed exclusively by native handles.

The package-root legacy Query remains separate and unchanged.

FieldRef

FieldRef(field_name, attr_type, entity_type)

Bases: Generic[T_Attribute, T_Owner_contra]

Type-safe reference to an entity field.

Returned when accessing entity class attributes (e.g., Person.age). Provides query methods like .gt(), .lt(), etc. that return typed expressions.

Create a field reference.

Parameters:

Name	Type	Description	Default
field_name	str	Python field name	required
attr_type	type[T_Attribute]	Attribute type class	required
entity_type	type[T_Owner_contra]	Entity type that owns this field	required

Source code in type_bridge/fields/base.py

def __init__(
    self,
    field_name: str,
    attr_type: type[T_Attribute],
    entity_type: type[T_Owner_contra],
):
    """Create a field reference.

    Args:
        field_name: Python field name
        attr_type: Attribute type class
        entity_type: Entity type that owns this field
    """
    self.field_name = field_name
    self.attr_type = attr_type
    self.entity_type = entity_type

lt

lt(value)

Create a less-than comparison expression.

Parameters:

Name	Type	Description	Default
value	T_Attribute	Value to compare against	required

Returns:

Type	Description
ComparisonExpr[T_Attribute]	ComparisonExpr for this field < value

Source code in type_bridge/fields/base.py

def lt(self, value: T_Attribute) -> "ComparisonExpr[T_Attribute]":
    """Create a less-than comparison expression.

    Args:
        value: Value to compare against

    Returns:
        ComparisonExpr for this field < value
    """
    # Delegate to attribute class method
    return self.attr_type.lt(value)

gt

gt(value)

Create a greater-than comparison expression.

Parameters:

Name	Type	Description	Default
value	T_Attribute	Value to compare against	required

Returns:

Type	Description
ComparisonExpr[T_Attribute]	ComparisonExpr for this field > value

Source code in type_bridge/fields/base.py

def gt(self, value: T_Attribute) -> "ComparisonExpr[T_Attribute]":
    """Create a greater-than comparison expression.

    Args:
        value: Value to compare against

    Returns:
        ComparisonExpr for this field > value
    """
    # Delegate to attribute class method
    return self.attr_type.gt(value)

lte

lte(value)

Create a less-than-or-equal comparison expression.

Parameters:

Name	Type	Description	Default
value	T_Attribute	Value to compare against	required

Returns:

Type	Description
ComparisonExpr[T_Attribute]	ComparisonExpr for this field <= value

Source code in type_bridge/fields/base.py

def lte(self, value: T_Attribute) -> "ComparisonExpr[T_Attribute]":
    """Create a less-than-or-equal comparison expression.

    Args:
        value: Value to compare against

    Returns:
        ComparisonExpr for this field <= value
    """
    # Delegate to attribute class method
    return self.attr_type.lte(value)

gte

gte(value)

Create a greater-than-or-equal comparison expression.

Parameters:

Name	Type	Description	Default
value	T_Attribute	Value to compare against	required

Returns:

Type	Description
ComparisonExpr[T_Attribute]	ComparisonExpr for this field >= value

Source code in type_bridge/fields/base.py

def gte(self, value: T_Attribute) -> "ComparisonExpr[T_Attribute]":
    """Create a greater-than-or-equal comparison expression.

    Args:
        value: Value to compare against

    Returns:
        ComparisonExpr for this field >= value
    """
    # Delegate to attribute class method
    return self.attr_type.gte(value)

eq

eq(value)

Create an equality comparison expression.

Parameters:

Name	Type	Description	Default
value	T_Attribute	Value to compare against	required

Returns:

Type	Description
ComparisonExpr[T_Attribute]	ComparisonExpr for this field == value

Source code in type_bridge/fields/base.py

def eq(self, value: T_Attribute) -> "ComparisonExpr[T_Attribute]":
    """Create an equality comparison expression.

    Args:
        value: Value to compare against

    Returns:
        ComparisonExpr for this field == value
    """
    # Delegate to attribute class method
    return self.attr_type.eq(value)

neq

neq(value)

Create a not-equal comparison expression.

Parameters:

Name	Type	Description	Default
value	T_Attribute	Value to compare against	required

Returns:

Type	Description
ComparisonExpr[T_Attribute]	ComparisonExpr for this field != value

Source code in type_bridge/fields/base.py

def neq(self, value: T_Attribute) -> "ComparisonExpr[T_Attribute]":
    """Create a not-equal comparison expression.

    Args:
        value: Value to compare against

    Returns:
        ComparisonExpr for this field != value
    """
    # Delegate to attribute class method
    return self.attr_type.neq(value)

RoleRef

RoleRef(role_name, player_types, cardinality=None, plays_cardinality=None, *, owner_type=None)

Bases: Generic[T_Player, T_RelationOwner_contra]

Reference to a role for type-safe attribute access.

Returned when accessing a Role descriptor from the Relation class level. Enables chained attribute access for building type-safe filter expressions.

Example

Employment.employee # Returns RoleRef[Person, Employment] Employment.employee.age # Returns RolePlayerNumericFieldRef[Age] Employment.employee.age.gt(Age(30)) # Returns RolePlayerExpr

For Role.multi() (polymorphic roles), attributes from all player types are available. If an attribute exists on at least one player type, it can be accessed.

Relations can also be role players

Permission.permitted_access # Returns RoleRef[Access, Permission]

Create a role reference.

Parameters:

Name	Type	Description	Default
role_name	str	Name of the role (e.g., "employee")	required
player_types	tuple[type[T_Player], ...]	Tuple of types (Entity or Relation) that can play this role	required
cardinality	Any	Optional relates-side role cardinality metadata.	None
plays_cardinality	Any	Optional plays-side cardinality metadata, carried as the sibling of cardinality so class-level role access exposes both axes.	None
owner_type	type[T_RelationOwner_contra] | None	Relation class that emitted this descriptor reference.	None

Source code in type_bridge/fields/role.py

def __init__(
    self,
    role_name: str,
    player_types: tuple[type[T_Player], ...],
    cardinality: Any = None,
    plays_cardinality: Any = None,
    *,
    owner_type: type[T_RelationOwner_contra] | None = None,
):
    """Create a role reference.

    Args:
        role_name: Name of the role (e.g., "employee")
        player_types: Tuple of types (Entity or Relation) that can play this role
        cardinality: Optional relates-side role cardinality metadata.
        plays_cardinality: Optional plays-side cardinality metadata, carried as the
            sibling of ``cardinality`` so class-level role access exposes both axes.
        owner_type: Relation class that emitted this descriptor reference.
    """
    self.role_name = role_name
    self.player_types = player_types
    self.owner_type = owner_type
    self.cardinality = cardinality
    self.plays_cardinality = plays_cardinality
    # Cache of collected attributes from all player types
    self._player_attrs: dict[str, tuple[type, Any]] | None = None

__getattr__

__getattr__(name)

Access role-player attribute for query building.

Parameters:

Name	Type	Description	Default
name	str	Attribute name to access	required

Returns:

Type	Description
RolePlayerFieldRef[Any]	Appropriate RolePlayerFieldRef subclass based on attribute type

Raises:

Type	Description
AttributeError	If attribute doesn't exist on any player type

Source code in type_bridge/fields/role.py

def __getattr__(self, name: str) -> RolePlayerFieldRef[Any]:
    """Access role-player attribute for query building.

    Args:
        name: Attribute name to access

    Returns:
        Appropriate RolePlayerFieldRef subclass based on attribute type

    Raises:
        AttributeError: If attribute doesn't exist on any player type
    """
    # Avoid infinite recursion for special attributes
    if name.startswith("_"):
        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")

    player_attrs = self._get_player_attrs()

    if name not in player_attrs:
        available = sorted(player_attrs.keys())
        raise AttributeError(
            f"Role '{self.role_name}' players do not have attribute '{name}'. "
            f"Available attributes: {available}"
        )

    attr_type, _attr_info = player_attrs[name]
    return self._make_field_ref(name, attr_type)

__dir__

__dir__()

Enable IDE autocompletion for available player attributes.

Returns:

Type	Description
list[str]	List of available attribute names from all player types

Source code in type_bridge/fields/role.py

def __dir__(self) -> list[str]:
    """Enable IDE autocompletion for available player attributes.

    Returns:
        List of available attribute names from all player types
    """
    return sorted(self._get_player_attrs().keys())

TypedQueryCapabilityError

TypedQueryCapabilityError(operation, cardinality)

Bases: RuntimeError

A validated typed request cannot run with the available native runtime.

Source code in type_bridge/typed/_terminal.py

def __init__(
    self,
    operation: MatchOperation,
    cardinality: RowCardinality | None,
) -> None:
    self.operation = operation
    self.cardinality = cardinality
    super().__init__(
        "the native typed-query executor/result materializer is unavailable; "
        f"validated {operation} request was not executed"
    )

TypedQueryConnectionError

TypedQueryConnectionError(code, message)

Bases: RuntimeError

A typed-query terminal has no usable owned or borrowed read target.

Source code in type_bridge/typed/_terminal.py

def __init__(self, code: str, message: str) -> None:
    self.code = code
    super().__init__(message)

TypedQueryWindowError

TypedQueryWindowError(code, message)

Bases: ValueError

A Python integer cannot form one canonical unsigned result window.

Source code in type_bridge/typed/_terminal.py

def __init__(self, code: str, message: str) -> None:
    self.code = code
    super().__init__(message)

Page dataclass

Page(items, offset, limit, total=None)

One bounded page of distinct, fully validated root results.

items is defensively converted to a tuple. The native executor is the authority for root identity, ordering, hydration, and totals; this wrapper only preserves those already-validated values as an immutable public envelope.

Source code in type_bridge/typed/page.py

def __init__(
    self,
    items: Iterable[T],
    offset: int,
    limit: int,
    total: int | None = None,
) -> None:
    if isinstance(offset, bool) or not isinstance(offset, int):
        raise TypeError("page offset must be an integer")
    if offset < 0:
        raise ValueError("page offset must be non-negative")
    if isinstance(limit, bool) or not isinstance(limit, int):
        raise TypeError("page limit must be an integer")
    if limit <= 0:
        raise ValueError("page limit must be positive")
    if total is not None:
        if isinstance(total, bool) or not isinstance(total, int):
            raise TypeError("page total must be an integer or None")
        if total < 0:
            raise ValueError("page total must be non-negative")
    object.__setattr__(self, "items", tuple(items))
    object.__setattr__(self, "offset", offset)
    object.__setattr__(self, "limit", limit)
    object.__setattr__(self, "total", total)

Query

Query()

One immutable positional query whose semantic state stays native-owned.

Source code in type_bridge/typed/query.py

def __init__(self) -> None:
    raise TypeError("Query values are created by QuerySession.query")

match

match(*bindings)

Return a sibling query with hidden witness bindings attached.

Source code in type_bridge/typed/query.py

def match(self, *bindings: _PlayerBinding[TypeDBType]) -> Query[*Slots]:
    """Return a sibling query with hidden witness bindings attached."""
    if not bindings:
        raise TypeError("Query.match requires at least one BoundVar")
    handle = self.__handle
    for binding in bindings:
        if not isinstance(binding, BoundVar):
            raise TypeError("Query.match requires BoundVar values")
        handle = handle.add_hidden(binding._native_binding())
    return Query._from_native(
        handle,
        self.__registry,
        self.__connection,
        self.__models,
        self.__declaration,
    )

where

where(*predicates)

Return a sibling query with predicates conjoined in call order.

Source code in type_bridge/typed/query.py

def where(self, *predicates: Predicate) -> Query[*Slots]:
    """Return a sibling query with predicates conjoined in call order."""
    if not predicates:
        raise TypeError("Query.where requires at least one Predicate")
    handle = self.__handle
    for predicate in predicates:
        if not isinstance(predicate, Predicate):
            raise TypeError("Query.where requires Predicate values")
        handle = handle.where_predicate(predicate._native_predicate())
    return Query._from_native(
        handle,
        self.__registry,
        self.__connection,
        self.__models,
        self.__declaration,
    )

allow_cross_join

allow_cross_join(left, right)

Return a sibling query with one explicit topology permission.

Source code in type_bridge/typed/query.py

def allow_cross_join[LeftT: TypeDBType, RightT: TypeDBType](
    self,
    left: BoundVar[LeftT],
    right: BoundVar[RightT],
) -> Query[*Slots]:
    """Return a sibling query with one explicit topology permission."""
    if not isinstance(left, BoundVar) or not isinstance(right, BoundVar):
        raise TypeError("Query.allow_cross_join requires BoundVar values")
    handle = self.__handle.allow_cross_join(left._native_binding(), right._native_binding())
    return Query._from_native(
        handle,
        self.__registry,
        self.__connection,
        self.__models,
        self.__declaration,
    )

one

one() -> SlotT

one() -> tuple[Slot1T, Slot2T, *RestT]

one()

Require exactly one distinct selected identity tuple.

Source code in type_bridge/typed/query.py

def one[Slot1T, Slot2T, *RestT](
    self: Query[Slot1T] | Query[Slot1T, Slot2T, *RestT],
) -> Slot1T | tuple[Slot1T, Slot2T, *RestT]:
    """Require exactly one distinct selected identity tuple."""
    result = execute_fetch_rows(
        self.__handle,
        self.__registry,
        self.__connection,
        [],
        0,
        1,
        "exactly_one",
    )
    return _materialize_one_for(self, result, self.__models, self.__declaration)

rows

rows(*, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = ()) -> list[SlotT]

rows(*, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = ()) -> list[tuple[Slot1T, Slot2T, *RestT]]

rows(*, limit, offset=0, order_by=())

Fetch a bounded list of distinct selected identity tuples.

Source code in type_bridge/typed/query.py

def rows[Slot1T, Slot2T, *RestT](
    self: Query[Slot1T] | Query[Slot1T, Slot2T, *RestT],
    *,
    limit: int,
    offset: int = 0,
    order_by: Iterable[QueryOrder] = (),
) -> list[Slot1T] | list[tuple[Slot1T, Slot2T, *RestT]]:
    """Fetch a bounded list of distinct selected identity tuples."""
    orders = _native_orders(order_by)
    offset, limit = _window(offset, limit)
    result = execute_fetch_rows(
        self.__handle,
        self.__registry,
        self.__connection,
        orders,
        offset,
        limit,
        "bounded_many",
    )
    return _materialize_rows_for(self, result, self.__models, self.__declaration)

page_by

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[SlotT]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...], tuple[Collected7T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT, tuple[Collected7T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT, tuple[Collected7T, ...], tuple[Collected8T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], RootT, tuple[Collected8T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT, tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], RootT, tuple[Collected8T, ...], tuple[Collected9T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], RootT, tuple[Collected9T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT, tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], RootT, tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], RootT, tuple[Collected9T, ...], tuple[Collected10T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], RootT, tuple[Collected10T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT, tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], RootT, tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], RootT, tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], RootT, tuple[Collected10T, ...], tuple[Collected11T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], RootT, tuple[Collected11T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT, tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], RootT, tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], RootT, tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], RootT, tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], RootT, tuple[Collected11T, ...], tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], RootT, tuple[Collected12T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT, tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], RootT, tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], RootT, tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], RootT, tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], RootT, tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], RootT, tuple[Collected12T, ...], tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], RootT, tuple[Collected13T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT, tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], RootT, tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], RootT, tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], RootT, tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], RootT, tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], RootT, tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], RootT, tuple[Collected13T, ...], tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], RootT, tuple[Collected14T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT, tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], RootT, tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], RootT, tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], RootT, tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], RootT, tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], RootT, tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], RootT, tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], RootT, tuple[Collected14T, ...], tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], RootT, tuple[Collected15T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], RootT]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[RootT, tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], RootT, tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], RootT, tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], RootT, tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], RootT, tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], RootT, tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], RootT, tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], RootT, tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], RootT, tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], RootT, tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], RootT, tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], RootT, tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], RootT, tuple[Collected14T, ...], tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], RootT, tuple[Collected15T, ...], tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], RootT, tuple[Collected16T, ...]]]

page_by(root: BoundVar[RootT], *, limit: int, offset: int = 0, order_by: Iterable[QueryOrder] = (), include_total: bool = False) -> Page[tuple[tuple[Collected1T, ...], tuple[Collected2T, ...], tuple[Collected3T, ...], tuple[Collected4T, ...], tuple[Collected5T, ...], tuple[Collected6T, ...], tuple[Collected7T, ...], tuple[Collected8T, ...], tuple[Collected9T, ...], tuple[Collected10T, ...], tuple[Collected11T, ...], tuple[Collected12T, ...], tuple[Collected13T, ...], tuple[Collected14T, ...], tuple[Collected15T, ...], RootT]]

page_by(root, *, limit, offset=0, order_by=(), include_total=False)

Page a native shape by one singular selected root identity.

Source code in type_bridge/typed/query.py

def page_by[RootT: TypeDBType](
    self,
    root: BoundVar[RootT],
    *,
    limit: int,
    offset: int = 0,
    order_by: Iterable[QueryOrder] = (),
    include_total: bool = False,
) -> Page[object]:
    """Page a native shape by one singular selected root identity."""
    if not isinstance(root, BoundVar):
        raise TypeError("Query.page_by requires a BoundVar root")
    if not isinstance(include_total, bool):
        raise TypeError("include_total must be a bool")
    orders = _native_orders(order_by)
    offset, limit = _window(offset, limit)
    result = execute_page_by(
        self.__handle,
        self.__registry,
        self.__connection,
        root._native_binding(),
        orders,
        offset,
        limit,
        include_total,
    )
    return _materialize_page(result, self.__models, self.__declaration)

count_by

count_by(root)

Count distinct identities for one attached root binding.

Source code in type_bridge/typed/query.py

def count_by[RootT: TypeDBType](self, root: BoundVar[RootT]) -> int:
    """Count distinct identities for one attached root binding."""
    if not isinstance(root, BoundVar):
        raise TypeError("Query.count_by requires a BoundVar root")
    result = execute_count_by(
        self.__handle,
        self.__registry,
        self.__connection,
        root._native_binding(),
    )
    return _materialize_count(result)

exists_by

exists_by(root)

Test whether one attached root binding has any distinct identity.

Source code in type_bridge/typed/query.py

def exists_by[RootT: TypeDBType](self, root: BoundVar[RootT]) -> bool:
    """Test whether one attached root binding has any distinct identity."""
    if not isinstance(root, BoundVar):
        raise TypeError("Query.exists_by requires a BoundVar root")
    result = execute_exists_by(
        self.__handle,
        self.__registry,
        self.__connection,
        root._native_binding(),
    )
    return _materialize_exists(result)

BoundField

BoundField()

Bases: _ImmutableNativeValue

Opaque field bound to one invariant native variable occurrence.

Source code in type_bridge/typed/references.py

def __init__(self) -> None:
    raise TypeError("BoundField values are created by BoundVar.field")

eq

eq(value)

Compare this field for equality with a typed literal or bound field.

Source code in type_bridge/typed/references.py

def eq(self, value: AttributeT | BoundField[AttributeT]) -> Predicate:
    """Compare this field for equality with a typed literal or bound field."""
    return self._compare("equal", value)

eq_field

eq_field(field)

Compare this field with another compatible bound field.

Source code in type_bridge/typed/references.py

def eq_field(self, field: BoundField[AttributeT]) -> Predicate:
    """Compare this field with another compatible bound field."""
    return self._compare("equal", field)

neq

neq(value)

Compare this field for inequality with a typed literal or bound field.

Source code in type_bridge/typed/references.py

def neq(self, value: AttributeT | BoundField[AttributeT]) -> Predicate:
    """Compare this field for inequality with a typed literal or bound field."""
    return self._compare("not_equal", value)

BoundRole

BoundRole()

Bases: _ImmutableNativeValue

Opaque relation role bound to one native relation variable.

Source code in type_bridge/typed/references.py

def __init__(self) -> None:
    raise TypeError("BoundRole values are created by BoundVar.role")

connects

connects(player)

Require this role to connect a compatible native bound variable.

Source code in type_bridge/typed/references.py

def connects(self, player: _PlayerBinding[PlayerT]) -> Predicate:
    """Require this role to connect a compatible native bound variable."""
    if not isinstance(player, BoundVar):
        raise TypeError("role players must be BoundVar values")
    return Predicate._from_native(self.__handle.connects(player._native_binding()))

is_

is_(player)

Require this role to be played by a compatible bound variable.

Source code in type_bridge/typed/references.py

def is_(self, player: _PlayerBinding[PlayerT]) -> Predicate:
    """Require this role to be played by a compatible bound variable."""
    return self.connects(player)

BoundVar

BoundVar()

Bases: Selection[ModelT], _PlayerBinding[ModelT]

Invariant model variable backed by one fresh native binding handle.

Source code in type_bridge/typed/references.py

def __init__(self) -> None:
    raise TypeError("BoundVar values are created by QuerySession.var")

field

field(reference: type[StringAttributeT]) -> _StringBoundField[StringAttributeT]

field(reference: type[NumericAttributeT]) -> _OrderedBoundField[NumericAttributeT]

field(reference: type[OrderedAttributeT]) -> _OrderedBoundField[OrderedAttributeT]

field(reference: type[AttributeT]) -> BoundField[AttributeT]

field(reference: StringFieldRef[StringAttributeT, ModelT]) -> _StringBoundField[StringAttributeT]

field(reference: NumericFieldRef[NumericAttributeT, ModelT]) -> _OrderedBoundField[NumericAttributeT]

field(reference: OrderedFieldRef[OrderedAttributeT, ModelT]) -> _OrderedBoundField[OrderedAttributeT]

field(reference: FieldRef[AttributeT, ModelT]) -> BoundField[AttributeT]

field(reference)

Bind an owned attribute class or legacy model field reference.

Source code in type_bridge/typed/references.py

def field(self, reference: Any) -> Any:
    """Bind an owned attribute class or legacy model field reference."""
    if isinstance(reference, type) and issubclass(reference, Attribute):
        field_name = self.__field_name_for_attribute(reference)
        handle = self.__handle.field(field_name)
        if issubclass(reference, String):
            return _StringBoundField._from_native(handle)
        if issubclass(reference, (NumericAttribute, Date, DateTime, DateTimeTZ)):
            return _OrderedBoundField._from_native(handle)
        return BoundField._from_native(handle)

    if not isinstance(reference, FieldRef):
        raise TypeError(
            "BoundVar.field requires an owned Attribute class or owner-aware FieldRef"
        )
    model_type_name = self.__stable_model_type_name()
    owner = _typed_query_field_reference_owner(reference)
    if owner is None:
        raise TypeError("BoundVar.field requires a FieldRef emitted by a model descriptor")
    owner_type, owner_type_name = owner
    if owner_type_name == model_type_name and owner_type is not self.__model:
        raise TypeError("BoundVar.field reference owner does not match the bound model")
    handle = self.__handle.field_owned_by(owner_type_name, reference.field_name)
    if isinstance(reference, StringFieldRef):
        return _StringBoundField._from_native(handle)
    if isinstance(reference, (NumericFieldRef, OrderedFieldRef)):
        return _OrderedBoundField._from_native(handle)
    return BoundField._from_native(handle)

__field_name_for_attribute

__field_name_for_attribute(attribute)

Resolve one exact attribute class through this binding's model owner.

Source code in type_bridge/typed/references.py

def __field_name_for_attribute(self, attribute: type[Attribute]) -> str:
    """Resolve one exact attribute class through this binding's model owner."""
    self.__stable_model_type_name()
    matches = [
        field_name
        for field_name, info in self.__model.get_all_attributes().items()
        if info.typ is attribute
    ]
    if not matches:
        raise TypeError(f"{self.__model.__name__} does not own attribute {attribute.__name__}")
    if len(matches) != 1:
        joined = ", ".join(sorted(matches))
        raise TypeError(
            f"{self.__model.__name__} owns attribute {attribute.__name__} through "
            f"multiple fields ({joined}); use the owner-aware model field reference"
        )
    return matches[0]

role

role(reference)

Bind one owner-aware relation role reference to this variable.

Source code in type_bridge/typed/references.py

def role(self, reference: RoleRef[PlayerT, ModelT]) -> BoundRole[PlayerT]:
    """Bind one owner-aware relation role reference to this variable."""
    if not isinstance(reference, RoleRef):
        raise TypeError("BoundVar.role requires an owner-aware RoleRef")
    model_type_name = self.__stable_model_type_name()
    owner = _typed_query_role_reference_owner(reference)
    if owner is None:
        raise TypeError("BoundVar.role requires a RoleRef emitted by a model descriptor")
    owner_type, owner_type_name = owner
    if owner_type_name == model_type_name and owner_type is not self.__model:
        raise TypeError("BoundVar.role reference owner does not match the bound model")
    return BoundRole._from_native(
        self.__handle.role_owned_by(owner_type_name, reference.role_name)
    )

collect

collect()

Return a persistent collected selection for this variable.

Source code in type_bridge/typed/references.py

def collect(self) -> Collected[ModelT]:
    """Return a persistent collected selection for this variable."""
    model_type_name = self.__stable_model_type_name()
    return Collected._from_native(self.__handle.collect(), self.__model, model_type_name)

Collected

Collected()

Bases: Selection[tuple[ModelT, ...]]

Persistent collected-output selection for one bound model variable.

Source code in type_bridge/typed/references.py

def __init__(self) -> None:
    raise TypeError("Collected values are created by BoundVar.collect")

distinct

distinct()

Return an identity-distinct persistent collection selection.

Source code in type_bridge/typed/references.py

def distinct(self) -> Collected[ModelT]:
    """Return an identity-distinct persistent collection selection."""
    return Collected._from_native(
        self.__handle.distinct(),
        self.__model,
        self.__model_type_name,
    )

order_by

order_by(order)

Append one native collection-member order term persistently.

Source code in type_bridge/typed/references.py

def order_by(self, order: QueryOrder) -> Collected[ModelT]:
    """Append one native collection-member order term persistently."""
    return Collected._from_native(
        self.__handle.order_by(order._native_order()),
        self.__model,
        self.__model_type_name,
    )

Predicate

Predicate()

Bases: _ImmutableNativeValue

Immutable boolean predicate whose referenced bindings remain native.

Source code in type_bridge/typed/references.py

def __init__(self) -> None:
    raise TypeError("Predicate values are created by bound reference operations")

and_

and_(other)

Return a persistent conjunction of this predicate and other.

Source code in type_bridge/typed/references.py

def and_(self, other: Predicate) -> Predicate:
    """Return a persistent conjunction of this predicate and ``other``."""
    return Predicate._from_native(self.__handle.and_(other.__handle))

or_

or_(other)

Return a persistent disjunction of this predicate and other.

Source code in type_bridge/typed/references.py

def or_(self, other: Predicate) -> Predicate:
    """Return a persistent disjunction of this predicate and ``other``."""
    return Predicate._from_native(self.__handle.or_(other.__handle))

not_

not_()

Return a persistent negation of this predicate.

Source code in type_bridge/typed/references.py

def not_(self) -> Predicate:
    """Return a persistent negation of this predicate."""
    return Predicate._from_native(self.__handle.not_())

QueryOrder

QueryOrder()

Bases: _ImmutableNativeValue

Opaque stable-order term created from an order-capable bound field.

Source code in type_bridge/typed/references.py

def __init__(self) -> None:
    raise TypeError("QueryOrder values are created by BoundField.asc/desc")

Selection

Bases: _ImmutableNativeValue, Generic[OutputT_co], ABC

Covariant output-only view of one native selection handle.

TypedQueryMaterializationError

TypedQueryMaterializationError(code, message)

Bases: RuntimeError

Validated native data cannot map exactly to registered Python models.

Source code in type_bridge/typed/results.py

def __init__(self, code: str, message: str) -> None:
    self.code = code
    super().__init__(message)

QuerySession

QuerySession(connection)

Own one native match lineage and its real connection context.

Source code in type_bridge/typed/session.py

def __init__(self, connection: Database | TransactionContext) -> None:
    if not isinstance(connection, (Database, TransactionContext)):
        raise TypeError("QuerySession requires a Database or TransactionContext")
    self.__initialize(connection)

var

var(model: type[ModelT], *, subtypes: Literal[False] = False) -> BoundVar[ModelT]

var(model: type[ModelT], *, subtypes: Literal[True]) -> BoundVar[ModelT]

var(model, *, subtypes=False)

Create a fresh exact or subtype-inclusive native variable.

Source code in type_bridge/typed/session.py

def var(self, model: type[ModelT], *, subtypes: bool = False) -> BoundVar[ModelT]:
    """Create a fresh exact or subtype-inclusive native variable."""
    if not isinstance(model, type) or not issubclass(model, TypeDBType):
        raise TypeError("QuerySession.var requires an Entity or Relation model class")
    if model in _FRAMEWORK_MODEL_ROOTS:
        raise TypeError("QuerySession.var requires a declared Entity or Relation model class")
    if model.is_base():
        raise TypeError("QuerySession.var cannot bind a Python-only base=True model class")
    registered: set[type[TypeDBType]] = set()
    subtype_roots: set[type[TypeDBType]] = set()
    self._register_descriptor_closure(model, registered, subtype_roots)
    if subtypes:
        self._register_loaded_subtypes(model, registered, subtype_roots)
    type_name = model.get_type_name()
    handle = self.__handle.subtypes(type_name) if subtypes else self.__handle.exact(type_name)
    return BoundVar._from_native(handle, model, type_name)

exact

exact(model)

Create a fresh exact-match variable for model.

Source code in type_bridge/typed/session.py

def exact(self, model: type[ModelT]) -> BoundVar[ModelT]:
    """Create a fresh exact-match variable for ``model``."""
    return self.var(model)

subtypes

subtypes(model)

Create a fresh subtype-inclusive variable for model.

Source code in type_bridge/typed/session.py

def subtypes(self, model: type[ModelT]) -> BoundVar[ModelT]:
    """Create a fresh subtype-inclusive variable for ``model``."""
    return self.var(model, subtypes=True)

query

query(selection1: Selection[T1]) -> Query[T1]

query(selection1: Selection[T1], selection2: Selection[T2]) -> Query[T1, T2]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3]) -> Query[T1, T2, T3]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4]) -> Query[T1, T2, T3, T4]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5]) -> Query[T1, T2, T3, T4, T5]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6]) -> Query[T1, T2, T3, T4, T5, T6]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6], selection7: Selection[T7]) -> Query[T1, T2, T3, T4, T5, T6, T7]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6], selection7: Selection[T7], selection8: Selection[T8]) -> Query[T1, T2, T3, T4, T5, T6, T7, T8]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6], selection7: Selection[T7], selection8: Selection[T8], selection9: Selection[T9]) -> Query[T1, T2, T3, T4, T5, T6, T7, T8, T9]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6], selection7: Selection[T7], selection8: Selection[T8], selection9: Selection[T9], selection10: Selection[T10]) -> Query[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6], selection7: Selection[T7], selection8: Selection[T8], selection9: Selection[T9], selection10: Selection[T10], selection11: Selection[T11]) -> Query[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6], selection7: Selection[T7], selection8: Selection[T8], selection9: Selection[T9], selection10: Selection[T10], selection11: Selection[T11], selection12: Selection[T12]) -> Query[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6], selection7: Selection[T7], selection8: Selection[T8], selection9: Selection[T9], selection10: Selection[T10], selection11: Selection[T11], selection12: Selection[T12], selection13: Selection[T13]) -> Query[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6], selection7: Selection[T7], selection8: Selection[T8], selection9: Selection[T9], selection10: Selection[T10], selection11: Selection[T11], selection12: Selection[T12], selection13: Selection[T13], selection14: Selection[T14]) -> Query[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6], selection7: Selection[T7], selection8: Selection[T8], selection9: Selection[T9], selection10: Selection[T10], selection11: Selection[T11], selection12: Selection[T12], selection13: Selection[T13], selection14: Selection[T14], selection15: Selection[T15]) -> Query[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]

query(selection1: Selection[T1], selection2: Selection[T2], selection3: Selection[T3], selection4: Selection[T4], selection5: Selection[T5], selection6: Selection[T6], selection7: Selection[T7], selection8: Selection[T8], selection9: Selection[T9], selection10: Selection[T10], selection11: Selection[T11], selection12: Selection[T12], selection13: Selection[T13], selection14: Selection[T14], selection15: Selection[T15], selection16: Selection[T16]) -> Query[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]

query(*selections)

Create one native positional query with between 1 and 16 slots.

Source code in type_bridge/typed/session.py

def query(self, *selections: Selection[object]) -> object:
    """Create one native positional query with between 1 and 16 slots."""
    if any(not isinstance(selection, Selection) for selection in selections):
        raise TypeError("QuerySession.query requires Selection values")
    shape = self.__handle.positional(
        [selection._native_selection() for selection in selections]
    )
    handle = self.__handle.query(shape)
    return Query._from_native(
        handle,
        self.__registry,
        self.__connection,
        self.__model_view,
    )

query_as

query_as(declaration, /, **selections)

Create a native named shape checked against one immutable row type.

Source code in type_bridge/typed/session.py

def query_as[DeclaredRowT](
    self,
    declaration: type[DeclaredRowT],
    /,
    **selections: Selection[object],
) -> Query[DeclaredRowT]:
    """Create a native named shape checked against one immutable row type."""
    declarations = _named_declaration(declaration)
    for selection in selections.values():
        if not isinstance(selection, Selection):
            raise TypeError("QuerySession.query_as values must be Selection values")

    names = list(selections)
    selected = list(selections.values())
    native_declarations = [
        (name, type_name, collection) for name, type_name, collection, _ in declarations
    ]
    shape = self.__handle.named_checked(
        native_declarations,
        names,
        [selection._native_selection() for selection in selected],
    )
    _validate_named_selection_models(declarations, selected)
    handle = self.__handle.query(shape)
    return Query._from_native(
        handle,
        self.__registry,
        self.__connection,
        self.__model_view,
        declaration,
    )