import re
import threading
from _typeshed import Incomplete, SupportsKeysAndGetItem
from collections.abc import Callable, Generator, Iterable, Iterator
from datetime import date, datetime, time
from decimal import Decimal
from types import TracebackType
from typing import Any, ClassVar, Final, Generic, Literal, NamedTuple, TypeAlias, TypedDict, overload, type_check_only
from typing_extensions import Self, TypeIs, TypeVar, Unpack
from uuid import UUID

def callable_(c: object) -> TypeIs[Callable[..., object]]: ...

multi_types: tuple[type[Incomplete], ...]

_T = TypeVar("_T")
_VT = TypeVar("_VT")
_F = TypeVar("_F", bound=Callable[..., Any])
_M = TypeVar("_M", bound=Model, default=Model)
# __get__/__set__ value type. Bare Field defaults to Field[Any].
_V = TypeVar("_V", default=Any)
_DatabaseType: TypeAlias = Database | DatabaseProxy

# Common field kwargs, Unpack-ed into the field __new__ overloads.
@type_check_only
class _FieldKwargs(TypedDict, total=False):
    index: bool
    unique: bool
    primary_key: bool
    column_name: str | None
    default: Any  # A value matching the field's type, or a callable returning one
    constraints: list[Node] | None
    sequence: str | None
    collation: str | None
    unindexed: bool
    choices: Iterable[tuple[Any, str]] | None  # (value, display) pairs (value type depends on the field)
    help_text: str | None
    verbose_name: str | None
    index_type: str | None
    db_column: str | None

@type_check_only
class _FKKwargs(_FieldKwargs, total=False):
    field: Field[Any] | str | None
    backref: str | Callable[[Field[Any]], str] | None
    on_delete: str | None
    on_update: str | None
    deferrable: str | None
    to_field: Field[Any] | str | None
    object_id_name: str | None
    lazy_load: bool
    constraint_name: str | None
    related_name: str | Callable[[Field[Any]], str] | None
    rel_model: type[Model] | None

class attrdict(dict[str, _VT]):
    def __getattr__(self, attr: str) -> _VT: ...
    def __setattr__(self, attr: str, value: _VT) -> None: ...
    # calls dict.update()
    def __iadd__(self, rhs: SupportsKeysAndGetItem[str, _VT] | Iterable[tuple[str, _VT]]) -> Self: ...
    def __add__(self, rhs: SupportsKeysAndGetItem[str, _VT] | Iterable[tuple[str, _VT]]) -> attrdict[_VT]: ...

OP: attrdict[str]
DJANGO_MAP: attrdict[Incomplete]
JOIN: attrdict[str]
ROW: attrdict[int]
PREFETCH_TYPE: attrdict[int]
SCOPE_NORMAL: Final = 1
SCOPE_SOURCE: Final = 2
SCOPE_VALUES: Final = 4
SCOPE_CTE: Final = 8
SCOPE_COLUMN: Final = 16
CSQ_PARENTHESES_NEVER: Final = 0
CSQ_PARENTHESES_ALWAYS: Final = 1
CSQ_PARENTHESES_UNNESTED: Final = 2
SNAKE_CASE_STEP1: Final[re.Pattern[str]]
SNAKE_CASE_STEP2: Final[re.Pattern[str]]
IDENTIFIER_RE: Final[re.Pattern[str]]

def make_identifier(s: str) -> str: ...
def chunked(it: Iterable[_T], n: int) -> Generator[list[_T]]: ...

class _callable_context_manager:
    def __call__(self, fn): ...

class Proxy:
    __slots__ = ("obj", "_callbacks")
    def __init__(self) -> None: ...
    obj: Incomplete
    def initialize(self, obj) -> None: ...
    def attach_callback(self, callback): ...
    def passthrough(method): ...
    __enter__: Incomplete
    __exit__: Incomplete
    def __getattr__(self, attr: str): ...
    def __setattr__(self, attr: str, value) -> None: ...

class DatabaseProxy(Proxy):
    __slots__ = ("obj", "_callbacks", "_Model")
    def connection_context(self) -> ConnectionContext: ...
    def atomic(self, *args, **kwargs) -> _atomic: ...
    def manual_commit(self) -> _manual: ...
    def transaction(self, *args, **kwargs) -> _transaction: ...
    def savepoint(self) -> _savepoint: ...
    @property
    def Model(self) -> type[Model]: ...

class ModelDescriptor: ...

class AliasManager:
    __slots__ = ("_counter", "_current_index", "_mapping")
    def __init__(self) -> None: ...
    @property
    def mapping(self): ...
    def add(self, source): ...
    def get(self, source, any_depth: bool = False): ...
    def __getitem__(self, source): ...
    def __setitem__(self, source, alias) -> None: ...
    def push(self) -> None: ...
    def pop(self) -> None: ...

class State:
    def __new__(cls, scope=1, parentheses: bool = False, **kwargs) -> Self: ...
    def __call__(self, scope=None, parentheses=None, **kwargs) -> State: ...
    def __getattr__(self, attr_name: str): ...

class Context:
    __slots__ = ("stack", "_sql", "_values", "alias_manager", "state")
    stack: list[Incomplete]
    alias_manager: AliasManager
    state: State
    def __init__(self, **settings) -> None: ...
    def as_new(self) -> Context: ...
    def column_sort_key(self, item): ...
    @property
    def scope(self): ...
    @property
    def parentheses(self): ...
    @property
    def subquery(self): ...
    def __call__(self, **overrides) -> Self: ...
    scope_normal: Incomplete
    scope_source: Incomplete
    scope_values: Incomplete
    scope_cte: Incomplete
    scope_column: Incomplete
    def __enter__(self) -> Self: ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...
    def push_alias(self) -> Generator[None]: ...
    def sql(self, obj): ...
    def literal(self, keyword) -> Self: ...
    def value(self, value, converter=None, add_param: bool = True): ...
    def __sql__(self, ctx): ...
    def parse(self, node): ...
    def query(self) -> tuple[str, list[Incomplete]]: ...

class Node:
    __isabstractmethod__: bool
    def clone(self) -> Self: ...
    def __sql__(self, ctx): ...
    @staticmethod
    def copy(method): ...
    def coerce(self, _coerce: bool = True) -> Self: ...
    def is_alias(self) -> bool: ...
    def unwrap(self) -> Self: ...

class ColumnFactory:
    __slots__ = ("node",)
    node: Node
    def __init__(self, node: Node) -> None: ...
    def __getattr__(self, attr: str) -> Column: ...
    __getitem__ = __getattr__

class _DynamicColumn:
    __slots__ = ()
    def __get__(self, instance, instance_type=None): ...

class _ExplicitColumn:
    __slots__ = ()
    def __get__(self, instance, instance_type=None) -> Self: ...

class Star(Node):
    def __init__(self, source) -> None: ...
    def __sql__(self, ctx): ...

class Source(Node):
    c: Incomplete
    def __init__(self, alias=None) -> None: ...
    def alias(self, name) -> Self: ...
    def select(self, *columns) -> Select: ...
    @property
    def __star__(self) -> Star: ...
    def join(self, dest, join_type="INNER JOIN", on=None) -> Join: ...
    def left_outer_join(self, dest, on=None) -> Join: ...
    def cte(self, name, recursive: bool = False, columns=None, materialized=None) -> CTE: ...
    def get_sort_key(self, ctx) -> tuple[Incomplete, ...]: ...
    def apply_alias(self, ctx): ...
    def apply_column(self, ctx): ...

class _HashableSource:
    def __init__(self, *args, **kwargs) -> None: ...
    def clone(self) -> _HashableSource: ...
    def alias(self, name) -> Self: ...
    def __hash__(self) -> int: ...
    def __eq__(self, other) -> Expression | bool: ...  # type: ignore[override]
    def __ne__(self, other) -> Expression | bool: ...  # type: ignore[override]
    __lt__: Callable[[Self, Any], Expression]
    __le__: Callable[[Self, Any], Expression]
    __gt__: Callable[[Self, Any], Expression]
    __ge__: Callable[[Self, Any], Expression]

class BaseTable(Source):
    def __and__(self, other) -> Join: ...
    def __add__(self, other) -> Join: ...
    def __sub__(self, other) -> Join: ...
    def __or__(self, other) -> Join: ...
    def __mul__(self, other) -> Join: ...
    def __rand__(self, other) -> Join: ...
    def __radd__(self, other) -> Join: ...
    def __rsub__(self, other) -> Join: ...
    def __ror__(self, other) -> Join: ...
    def __rmul__(self, other) -> Join: ...

class _BoundTableContext(_callable_context_manager):
    table: Incomplete
    database: Incomplete
    def __init__(self, table, database: _DatabaseType) -> None: ...
    def __enter__(self): ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...

class Table(_HashableSource, BaseTable):  # type: ignore[misc]
    __name__: Incomplete
    c: Incomplete
    primary_key: Incomplete
    def __init__(
        self, name, columns=None, primary_key=None, schema: str | None = None, alias=None, _model=None, _database=None
    ) -> None: ...
    def clone(self) -> Table: ...
    def bind(self, database: _DatabaseType | None = None) -> Self: ...
    def bind_ctx(self, database: _DatabaseType | None = None) -> _BoundTableContext: ...
    def select(self, *columns) -> Select: ...
    def insert(self, insert=None, columns=None, **kwargs) -> Insert: ...
    def replace(self, insert=None, columns=None, **kwargs): ...
    def update(self, update=None, **kwargs) -> Update: ...
    def delete(self) -> Delete: ...
    def __sql__(self, ctx): ...

class Join(BaseTable):
    lhs: Incomplete
    rhs: Incomplete
    join_type: Incomplete
    def __init__(self, lhs, rhs, join_type="INNER JOIN", on=None, alias=None) -> None: ...
    def on(self, predicate) -> Self: ...
    def __sql__(self, ctx): ...

class ValuesList(_HashableSource, BaseTable):  # type: ignore[misc]
    def __init__(self, values, columns=None, alias=None) -> None: ...
    def columns(self, *names) -> Self: ...
    def __sql__(self, ctx): ...

class CTE(_HashableSource, Source):  # type: ignore[misc]
    def __init__(self, name, query, recursive: bool = False, columns=None, materialized=None) -> None: ...
    def select_from(self, *columns) -> Select: ...
    def union_all(self, rhs) -> CTE: ...
    __add__ = union_all
    def union(self, rhs) -> CTE: ...
    __or__ = union
    def __sql__(self, ctx): ...

class ColumnBase(Node):
    def converter(self, converter=None) -> Self: ...
    def alias(self, alias) -> Alias | Self: ...
    def unalias(self) -> Self: ...
    def bind_to(self, dest) -> BindTo: ...
    def cast(self, as_type) -> Cast: ...
    def asc(self, collation=None, nulls=None) -> Ordering: ...
    __pos__ = asc
    def desc(self, collation=None, nulls=None) -> Ordering: ...
    __neg__ = desc
    def __invert__(self): ...
    __and__: ClassVar[Callable[[Self, Any], Expression]]
    __or__: ClassVar[Callable[[Self, Any], Expression]]
    def __add__(self, rhs: Any) -> Expression: ...
    __sub__: ClassVar[Callable[[Self, Any], Expression]]
    __mul__: ClassVar[Callable[[Self, Any], Expression]]
    __truediv__: ClassVar[Callable[[Self, Any], Expression]]
    __xor__: ClassVar[Callable[[Self, Any], Expression]]
    def __radd__(self, rhs: Any) -> Expression: ...
    __rsub__: ClassVar[Callable[[Self, Any], Expression]]
    __rmul__: ClassVar[Callable[[Self, Any], Expression]]
    __rtruediv__: ClassVar[Callable[[Self, Any], Expression]]
    __rand__: ClassVar[Callable[[Self, Any], Expression]]
    __ror__: ClassVar[Callable[[Self, Any], Expression]]
    __rxor__: ClassVar[Callable[[Self, Any], Expression]]
    def __eq__(self, rhs) -> Expression: ...  # type: ignore[override]
    def __ne__(self, rhs) -> Expression: ...  # type: ignore[override]
    __lt__: ClassVar[Callable[[Self, Any], Expression]]
    __le__: ClassVar[Callable[[Self, Any], Expression]]
    __gt__: ClassVar[Callable[[Self, Any], Expression]]
    __ge__: ClassVar[Callable[[Self, Any], Expression]]
    __lshift__: ClassVar[Callable[[Self, Any], Expression]]
    __rshift__: ClassVar[Callable[[Self, Any], Expression]]
    __mod__: ClassVar[Callable[[Self, Any], Expression]]
    __pow__: ClassVar[Callable[[Self, Any], Expression]]
    like: ClassVar[Callable[[Self, Any], Expression]]
    ilike: ClassVar[Callable[[Self, Any], Expression]]
    bin_and: ClassVar[Callable[[Self, Any], Expression]]
    bin_or: ClassVar[Callable[[Self, Any], Expression]]
    in_: ClassVar[Callable[[Self, Any], Expression]]
    not_in: ClassVar[Callable[[Self, Any], Expression]]
    regexp: ClassVar[Callable[[Self, Any], Expression]]
    iregexp: ClassVar[Callable[[Self, Any], Expression]]
    def is_null(self, is_null: bool = True) -> Expression: ...
    def contains(self, rhs) -> Expression: ...
    def startswith(self, rhs) -> Expression: ...
    def endswith(self, rhs) -> Expression: ...
    def between(self, lo, hi) -> Expression: ...
    def concat(self, rhs) -> StringExpression: ...
    def __getitem__(self, item): ...
    __iter__: Incomplete
    def distinct(self) -> NodeList: ...
    def collate(self, collation) -> NodeList: ...
    def get_sort_key(self, ctx) -> tuple[Incomplete, ...]: ...

class Column(ColumnBase):
    source: Incomplete
    name: Incomplete
    def __init__(self, source, name) -> None: ...
    def get_sort_key(self, ctx) -> tuple[Incomplete, ...]: ...
    def __hash__(self) -> int: ...
    def __sql__(self, ctx): ...

class WrappedNode(ColumnBase):
    node: Incomplete
    def __init__(self, node) -> None: ...
    def is_alias(self) -> bool: ...
    def unwrap(self): ...

class EntityFactory:
    __slots__ = ("node",)
    node: Incomplete
    def __init__(self, node) -> None: ...
    def __getattr__(self, attr: str) -> Entity: ...

class _DynamicEntity:
    __slots__ = ()
    def __get__(self, instance, instance_type=None): ...

class Alias(WrappedNode):
    c: Incomplete
    def __init__(self, node, alias) -> None: ...
    def __hash__(self) -> int: ...

    @property
    def name(self): ...
    @name.setter
    def name(self, value) -> None: ...

    def alias(self, alias=None): ...
    def unalias(self): ...
    def is_alias(self) -> bool: ...
    def __sql__(self, ctx): ...

class BindTo(WrappedNode):
    dest: Incomplete
    def __init__(self, node, dest) -> None: ...
    def __sql__(self, ctx): ...

class Negated(WrappedNode):
    def __invert__(self): ...
    def __sql__(self, ctx): ...

class BitwiseMixin:
    def __and__(self, other) -> Expression: ...
    def __or__(self, other) -> Expression: ...
    def __sub__(self, other) -> Expression: ...
    def __invert__(self) -> BitwiseNegated: ...

class BitwiseNegated(BitwiseMixin, WrappedNode):
    op: str
    def __invert__(self): ...
    def __sql__(self, ctx): ...

class Value(ColumnBase):
    value: Incomplete
    converter: Incomplete
    multi: bool
    values: list[Incomplete] | None
    def __init__(self, value, converter=None, unpack: bool = True) -> None: ...
    def __sql__(self, ctx): ...

class ValueLiterals(WrappedNode):
    def __sql__(self, ctx): ...

def AsIs(value, converter=None) -> Value: ...

class Cast(WrappedNode):
    def __init__(self, node, cast) -> None: ...
    def __sql__(self, ctx): ...

class Ordering(WrappedNode):
    direction: Incomplete
    collation: Incomplete
    nulls: Incomplete
    def __init__(self, node, direction, collation=None, nulls=None) -> None: ...
    def collate(self, collation=None) -> Ordering: ...  # type: ignore[override]
    def __sql__(self, ctx): ...

def Asc(node, collation=None, nulls=None) -> Ordering: ...
def Desc(node, collation=None, nulls=None) -> Ordering: ...

class Expression(ColumnBase):
    lhs: Incomplete
    op: Incomplete
    rhs: Incomplete
    flat: bool
    def __init__(self, lhs, op, rhs, flat: bool = False) -> None: ...
    def __sql__(self, ctx): ...

class StringExpression(Expression):
    def __add__(self, rhs) -> StringExpression: ...
    def __radd__(self, lhs) -> StringExpression: ...

class Entity(ColumnBase):
    def __init__(self, *path) -> None: ...
    def __getattr__(self, attr: str) -> Entity: ...
    def get_sort_key(self, ctx) -> tuple[Incomplete, ...]: ...
    def __hash__(self) -> int: ...
    def __sql__(self, ctx): ...

class SQL(ColumnBase):
    sql: Incomplete
    params: Incomplete
    def __init__(self, sql, params=None) -> None: ...
    def __sql__(self, ctx): ...

def Check(constraint: str, name: str | None = None) -> SQL | NodeList: ...
def Default(value) -> SQL: ...

class Function(ColumnBase):
    no_coerce_functions: ClassVar[set[str]]
    name: str | None
    arguments: tuple[Any, ...] | None  # Positional SQL function args: values, columns, or other nodes
    def __init__(self, name, arguments, coerce: bool = True, python_value=None) -> None: ...
    # fn.COUNT(...), fn.SUM(...), etc. each build a Function node.
    def __getattr__(self, attr: str) -> Callable[..., Function]: ...
    def filter(self, where=None) -> Self: ...
    def order_by(self, *ordering) -> Self: ...
    def python_value(self, func=None) -> Self: ...
    def over(
        self, partition_by=None, order_by=None, start=None, end=None, frame_type=None, window=None, exclude=None
    ) -> NodeList: ...
    def __sql__(self, ctx): ...

fn: Function

class Window(Node):
    CURRENT_ROW: SQL
    GROUP: SQL
    TIES: SQL
    NO_OTHERS: SQL
    GROUPS: str
    RANGE: str
    ROWS: str
    partition_by: Incomplete
    order_by: Incomplete
    start: Incomplete
    end: Incomplete
    frame_type: Incomplete
    def __init__(
        self,
        partition_by=None,
        order_by=None,
        start=None,
        end=None,
        frame_type=None,
        extends=None,
        exclude=None,
        alias=None,
        _inline: bool = False,
    ) -> None: ...
    def alias(self, alias=None) -> Self: ...
    def as_range(self) -> Self: ...
    def as_rows(self) -> Self: ...
    def as_groups(self) -> Self: ...
    def extends(self, window=None) -> Self: ...
    def exclude(self, frame_exclusion=None) -> Self: ...
    @staticmethod
    def following(value=None) -> SQL: ...
    @staticmethod
    def preceding(value=None) -> SQL: ...
    def __sql__(self, ctx): ...

class WindowAlias(Node):
    window: Incomplete
    def __init__(self, window) -> None: ...
    def alias(self, window_alias) -> Self: ...
    def __sql__(self, ctx): ...

class ForUpdate(Node):
    def __init__(self, expr, of=None, nowait: bool | None = None, skip_locked: bool | None = None) -> None: ...
    def __sql__(self, ctx): ...

class Case(ColumnBase):
    predicate: Incomplete
    expression_tuples: Incomplete
    default: Incomplete | None
    def __init__(self, predicate, expression_tuples, default=None) -> None: ...
    def __sql__(self, ctx): ...

class NodeList(ColumnBase):
    nodes: Incomplete
    glue: Incomplete
    parens: bool
    def __init__(self, nodes, glue: str = " ", parens: bool = False) -> None: ...
    def __sql__(self, ctx): ...

def CommaNodeList(nodes) -> NodeList: ...
def EnclosedNodeList(nodes) -> NodeList: ...

class _Namespace(Node):
    __slots__ = ("_name",)
    def __init__(self, name) -> None: ...
    def __getattr__(self, attr: str) -> NamespaceAttribute: ...
    __getitem__ = __getattr__

class NamespaceAttribute(ColumnBase):
    def __init__(self, namespace, attribute) -> None: ...
    def __sql__(self, ctx): ...

EXCLUDED: Incomplete

class DQ(ColumnBase):
    query: Incomplete
    def __init__(self, **query) -> None: ...
    def __invert__(self) -> Self: ...  # type: ignore[override]
    def clone(self) -> DQ: ...

Tuple: Incomplete

class QualifiedNames(WrappedNode):
    def __init__(self, node, scope=SCOPE_COLUMN) -> None: ...
    def __sql__(self, ctx): ...

class OnConflict(Node):
    def __init__(
        self,
        action=None,
        update=None,
        preserve=None,
        where=None,
        conflict_target=None,
        conflict_where=None,
        conflict_constraint=None,
    ) -> None: ...
    def get_conflict_statement(self, ctx, query): ...
    def get_conflict_update(self, ctx, query): ...
    def preserve(self, *columns) -> Self: ...
    def update(self, _data=None, **kwargs) -> Self: ...
    def where(self, *expressions) -> Self: ...
    def conflict_target(self, *constraints) -> Self: ...
    def conflict_where(self, *expressions) -> Self: ...
    def conflict_constraint(self, constraint) -> Self: ...

class BaseQuery(Node):
    default_row_type: Incomplete
    def __init__(self, _database=None, **kwargs) -> None: ...
    def bind(self, database: _DatabaseType | None = None) -> Self: ...
    def clone(self) -> Self: ...
    def dicts(self, as_dict: bool = True) -> Self: ...
    def tuples(self, as_tuple: bool = True) -> Self: ...
    def namedtuples(self, as_namedtuple: bool = True) -> Self: ...
    def objects(self, constructor=None) -> Self: ...
    def __sql__(self, ctx) -> None: ...
    def sql(self) -> tuple[str, list[Any]]: ...  # Returns (sql, params), params are bound query values
    def execute(self, database: _DatabaseType | None = None): ...
    async def aexecute(self, database: _DatabaseType | None = None): ...
    def iterator(self, database: _DatabaseType | None = None): ...
    def __iter__(self): ...
    def __getitem__(self, value): ...
    def __len__(self) -> int: ...

class RawQuery(BaseQuery):
    def __init__(self, sql=None, params=None, **kwargs) -> None: ...
    def __sql__(self, ctx): ...

class Query(BaseQuery):
    def __init__(self, where=None, order_by=None, limit=None, offset=None, **kwargs) -> None: ...
    def with_cte(self, *cte_list) -> Self: ...
    def where(self, *expressions) -> Self: ...
    def orwhere(self, *expressions) -> Self: ...
    def order_by(self, *values) -> Self: ...
    def order_by_extend(self, *values) -> Self: ...
    def limit(self, value=None) -> Self: ...
    def offset(self, value=None) -> Self: ...
    def paginate(self, page, paginate_by: int = 20) -> Self: ...
    def __sql__(self, ctx): ...

class SelectQuery(Query):
    def union_all(self, other) -> CompoundSelectQuery: ...
    def __add__(self, other) -> CompoundSelectQuery: ...
    def union(self, other) -> CompoundSelectQuery: ...
    def __or__(self, other) -> CompoundSelectQuery: ...
    def intersect(self, other) -> CompoundSelectQuery: ...
    def __and__(self, other) -> CompoundSelectQuery: ...
    def except_(self, other) -> CompoundSelectQuery: ...
    def __sub__(self, other) -> CompoundSelectQuery: ...
    def __radd__(self, other) -> CompoundSelectQuery: ...
    def __ror__(self, other) -> CompoundSelectQuery: ...
    def __rand__(self, other) -> CompoundSelectQuery: ...
    def __rsub__(self, other) -> CompoundSelectQuery: ...
    def select_from(self, *columns) -> Select: ...

class SelectBase(_HashableSource, Source, SelectQuery):  # type: ignore[misc]
    def peek(self, database: _DatabaseType | None = None, n: int = 1): ...
    def first(self, database: _DatabaseType | None = None, n: int = 1): ...
    def scalar(self, database: _DatabaseType | None = None, as_tuple: bool = False, as_dict: bool = False): ...
    def scalars(self, database: _DatabaseType | None = None) -> Generator[Incomplete]: ...
    def count(self, database: _DatabaseType | None = None, clear_limit: bool = False) -> int: ...
    def exists(self, database: _DatabaseType | None = None) -> bool: ...
    def get(self, database: _DatabaseType | None = None): ...

class CompoundSelectQuery(SelectBase):
    lhs: Incomplete
    op: Incomplete
    rhs: Incomplete
    def __init__(self, lhs, op, rhs) -> None: ...
    def exists(self, database: _DatabaseType | None = None) -> bool: ...
    def __sql__(self, ctx): ...

class Select(SelectBase):
    def __init__(
        self,
        from_list=None,
        columns=None,
        group_by=None,
        having=None,
        distinct=None,
        windows=None,
        for_update=None,
        lateral=None,
        **kwargs,
    ) -> None: ...
    def clone(self) -> Self: ...
    def columns(self, *columns) -> Self: ...
    select = columns
    def select_extend(self, *columns) -> Self: ...

    @property
    def selected_columns(self): ...
    @selected_columns.setter
    def selected_columns(self, value) -> None: ...

    def from_(self, *sources) -> Self: ...
    def join(self, dest, join_type="INNER JOIN", on=None) -> Self: ...  # type: ignore[override]
    def left_outer_join(self, dest, on=None) -> Self: ...  # type: ignore[override]
    def group_by(self, *columns) -> Self: ...
    def group_by_extend(self, *values) -> Self: ...
    def having(self, *expressions) -> Self: ...
    def distinct(self, *columns) -> Self: ...
    def window(self, *windows) -> Self: ...
    def for_update(
        self, for_update: bool = True, of=None, nowait: bool | None = None, skip_locked: bool | None = None
    ) -> Self: ...
    def lateral(self, lateral: bool = True) -> Self: ...
    def __sql_selection__(self, ctx, is_subquery: bool = False): ...
    def __sql__(self, ctx): ...

class _WriteQuery(Query):
    table: Incomplete
    def __init__(self, table, returning=None, **kwargs) -> None: ...
    def cte(self, name, recursive: bool = False, columns=None, materialized=None) -> CTE: ...
    def returning(self, *returning) -> Self: ...
    def apply_returning(self, ctx): ...
    def execute_returning(self, database: _DatabaseType): ...
    def handle_result(self, database: _DatabaseType, cursor): ...
    def __sql__(self, ctx): ...

class Update(_WriteQuery):
    def __init__(self, table, update=None, **kwargs) -> None: ...
    def from_(self, *sources) -> Self: ...
    def __sql__(self, ctx): ...

class Insert(_WriteQuery):
    SIMPLE: int
    QUERY: int
    MULTI: int

    class DefaultValuesException(Exception): ...

    def __init__(self, table, insert=None, columns=None, on_conflict=None, **kwargs) -> None: ...
    def where(self, *expressions): ...
    def as_rowcount(self, _as_rowcount: bool = True) -> Self: ...
    def on_conflict_ignore(self, ignore: bool = True) -> Self: ...
    def on_conflict_replace(self, replace: bool = True) -> Self: ...
    def on_conflict(self, *args, **kwargs) -> Self: ...
    def get_default_data(self): ...
    def get_default_columns(self) -> list[Incomplete] | None: ...
    def __sql__(self, ctx): ...
    def handle_result(self, database: _DatabaseType, cursor): ...

class Delete(_WriteQuery):
    def __sql__(self, ctx): ...

class Index(Node):
    def __init__(
        self, name, table, expressions, unique: bool = False, safe: bool = False, where=None, using=None, nulls_distinct=None
    ) -> None: ...
    def safe(self, _safe: bool = True) -> Self: ...
    def where(self, *expressions) -> Self: ...
    def using(self, _using=None) -> Self: ...
    def nulls_distinct(self, nulls_distinct=None) -> Self: ...
    def __sql__(self, ctx): ...

class ModelIndex(Index):
    def __init__(
        self, model, fields, unique: bool = False, safe: bool = True, where=None, using=None, name=None, nulls_distinct=None
    ) -> None: ...

class PeeweeException(Exception):
    def __init__(self, *args) -> None: ...

class ImproperlyConfigured(PeeweeException): ...
class DatabaseError(PeeweeException): ...
class DataError(DatabaseError): ...
class IntegrityError(DatabaseError): ...
class InterfaceError(PeeweeException): ...
class InternalError(DatabaseError): ...
class NotSupportedError(DatabaseError): ...
class OperationalError(DatabaseError): ...
class ProgrammingError(DatabaseError): ...

class ExceptionWrapper:
    __slots__ = ("exceptions",)
    exceptions: Incomplete
    def __init__(self, exceptions) -> None: ...
    def __enter__(self) -> None: ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
    ) -> None: ...

class IndexMetadata(NamedTuple):
    name: Incomplete
    sql: Incomplete
    columns: Incomplete
    unique: Incomplete
    table: Incomplete

class ColumnMetadata(NamedTuple):
    name: Incomplete
    data_type: Incomplete
    null: Incomplete
    primary_key: Incomplete
    table: Incomplete
    default: Incomplete
    full_type: str | None = ...
    identity: bool = ...

class ForeignKeyMetadata(NamedTuple):
    column: Incomplete
    dest_table: Incomplete
    dest_column: Incomplete
    table: Incomplete
    name: str | None = ...
    on_delete: str | None = ...
    on_update: str | None = ...

class ViewMetadata(NamedTuple):
    name: Incomplete
    sql: Incomplete

class _ConnectionState:
    def __init__(self, **kwargs) -> None: ...
    closed: bool
    conn: Incomplete
    ctx: Incomplete
    transactions: Incomplete
    def reset(self) -> None: ...
    def set_connection(self, conn) -> None: ...

class _ConnectionLocal(_ConnectionState, threading.local): ...

class _NoopLock:
    __slots__ = ()
    def __enter__(self) -> Self: ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...

class ConnectionContext(_callable_context_manager):
    __slots__ = ("db",)
    db: Incomplete
    def __init__(self, db) -> None: ...
    def __enter__(self) -> None: ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...

class Database(_callable_context_manager):
    context_class: Incomplete
    json_methods: Incomplete
    field_types: Incomplete
    operations: Incomplete
    param: str
    quote: str
    server_version: Incomplete
    compound_select_parentheses: Incomplete
    for_update: bool
    index_schema_prefix: bool
    index_using_precedes_table: bool
    index_value_literals: bool
    limit_max: Incomplete
    nulls_ordering: bool
    returning_clause: bool
    safe_create_index: bool
    safe_drop_index: bool
    sequences: bool
    truncate_table: bool
    autoconnect: Incomplete
    thread_safe: Incomplete
    connect_params: Incomplete
    def __deepcopy__(self, memo: Any) -> Self: ...
    def __init__(
        self,
        database: str | None,
        thread_safe: bool = True,
        autorollback: bool = False,
        field_types=None,
        operations=None,
        autocommit=None,
        autoconnect: bool = True,
        **kwargs,
    ) -> None: ...
    database: Incomplete
    deferred: Incomplete
    def init(self, database: str | None, **kwargs) -> None: ...
    def __enter__(self) -> Self: ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...
    def connection_context(self) -> ConnectionContext: ...
    def connect(self, reuse_if_open: bool = False) -> bool: ...
    def close(self) -> bool: ...
    def is_closed(self) -> bool: ...
    def is_connection_usable(self) -> bool: ...
    def connection(self): ...
    def cursor(self, named_cursor=None): ...
    def execute_sql(self, sql, params=None): ...
    def execute(self, query, **context_options): ...
    def get_context_options(self) -> dict[str, Incomplete]: ...
    def get_sql_context(self, **context_options) -> context_class: ...
    def conflict_statement(self, on_conflict, query): ...
    def conflict_update(self, on_conflict, query): ...
    def last_insert_id(self, cursor, query_type=None): ...
    def rows_affected(self, cursor): ...
    def default_values_insert(self, ctx): ...
    def session_start(self) -> _transaction: ...
    def session_commit(self) -> bool: ...
    def session_rollback(self) -> bool: ...
    def in_transaction(self) -> bool: ...
    def push_transaction(self, transaction) -> None: ...
    def pop_transaction(self): ...
    def transaction_depth(self) -> int: ...
    def top_transaction(self): ...
    def atomic(self, *args, **kwargs) -> _atomic: ...
    def manual_commit(self) -> _manual: ...
    def transaction(self, *args, **kwargs) -> _transaction: ...
    def savepoint(self) -> _savepoint: ...
    def begin(self) -> None: ...
    def commit(self) -> None: ...
    def rollback(self) -> None: ...
    def batch_commit(self, it, n) -> Generator[Incomplete]: ...
    def table_exists(self, table_name, schema: str | None = None) -> bool: ...
    def get_tables(self, schema: str | None = None) -> list[str]: ...
    def get_indexes(self, table, schema: str | None = None) -> list[IndexMetadata]: ...
    def get_columns(self, table, schema: str | None = None) -> list[ColumnMetadata]: ...
    def get_primary_keys(self, table, schema: str | None = None): ...
    def get_foreign_keys(self, table, schema: str | None = None) -> list[ForeignKeyMetadata]: ...
    def sequence_exists(self, seq) -> bool: ...
    def create_tables(self, models: Iterable[type[Model]], **options) -> None: ...
    def drop_tables(self, models: Iterable[type[Model]], **kwargs) -> None: ...
    def extract_date(self, date_part, date_field): ...
    def truncate_date(self, date_part, date_field): ...
    def to_timestamp(self, date_field): ...
    def from_timestamp(self, date_field): ...
    def random(self): ...
    def bind(self, models: Iterable[type[Model]], bind_refs: bool = True, bind_backrefs: bool = True) -> None: ...
    def bind_ctx(
        self, models: Iterable[type[Model]], bind_refs: bool = True, bind_backrefs: bool = True
    ) -> _BoundModelsContext: ...
    def get_noop_select(self, ctx): ...
    @property
    def Model(self) -> type[Model]: ...

class SqliteDatabase(Database):
    field_types: Incomplete
    operations: Incomplete
    index_schema_prefix: bool
    index_value_literals: bool
    limit_max: int
    server_version: Incomplete
    truncate_table: bool
    nulls_ordering: bool
    def __init__(
        self, database: str | None, pragmas=None, regexp_function: bool = False, rank_functions: bool = False, *args, **kwargs
    ) -> None: ...
    returning_clause: Incomplete
    def init(self, database: str | None, pragmas=None, timeout: int = 5, returning_clause=None, **kwargs) -> None: ...
    def pragma(self, key, value=..., permanent: bool = False, schema: str | None = None): ...
    cache_size: Incomplete
    foreign_keys: Incomplete
    journal_mode: Incomplete
    journal_size_limit: Incomplete
    mmap_size: Incomplete
    page_size: Incomplete
    read_uncommitted: Incomplete
    synchronous: Incomplete
    wal_autocheckpoint: Incomplete
    application_id: Incomplete
    user_version: Incomplete
    data_version: Incomplete

    @property
    def timeout(self): ...
    @timeout.setter
    def timeout(self, seconds) -> None: ...

    def register_aggregate(self, klass, name=None, num_params: int = -1) -> None: ...
    def aggregate(self, name=None, num_params: int = -1): ...
    def register_collation(self, fn, name=None) -> None: ...
    def collation(self, name=None): ...
    def register_function(self, fn, name: str | None = None, num_params: int = -1, deterministic: bool | None = None) -> None: ...
    def func(self, name: str | None = None, num_params: int = -1, deterministic: bool | None = None) -> Callable[[_F], _F]: ...
    def register_window_function(self, klass, name=None, num_params: int = -1) -> None: ...
    def window_function(self, name=None, num_params: int = -1): ...
    def unregister_aggregate(self, name) -> None: ...
    def unregister_collation(self, name) -> None: ...
    def unregister_function(self, name) -> None: ...
    def unregister_window_function(self, name) -> None: ...
    def load_extension(self, extension) -> None: ...
    def unload_extension(self, extension) -> None: ...
    def attach(self, filename, name) -> bool: ...
    def detach(self, name) -> bool: ...
    def last_insert_id(self, cursor, query_type=None): ...
    def begin(self, lock_type=None) -> None: ...
    def get_tables(self, schema: str | None = None) -> list[str]: ...
    def get_views(self, schema: str | None = None) -> list[ViewMetadata]: ...
    def get_indexes(self, table, schema: str | None = None) -> list[IndexMetadata]: ...
    def get_columns(self, table, schema: str | None = None) -> list[ColumnMetadata]: ...
    def get_primary_keys(self, table, schema: str | None = None) -> list[Incomplete]: ...
    def get_foreign_keys(self, table, schema: str | None = None) -> list[ForeignKeyMetadata]: ...
    def get_binary_type(self): ...
    def conflict_statement(self, on_conflict, query) -> SQL | None: ...
    def conflict_update(self, oc, query) -> SQL | NodeList | None: ...
    def extract_date(self, date_part, date_field) -> Function: ...
    def truncate_date(self, date_part, date_field) -> Function: ...
    def to_timestamp(self, date_field) -> Cast: ...
    def from_timestamp(self, date_field) -> Function: ...

class _BasePsycopgAdapter:
    isolation_levels: dict[int, str]
    isolation_levels_inv: dict[str, int]
    def __init__(self) -> None: ...

    @overload
    def isolation_level_int(self, isolation_level: str) -> int: ...
    @overload
    def isolation_level_int(self, isolation_level: _T) -> _T: ...

    @overload
    def isolation_level_str(self, isolation_level: int) -> str: ...
    @overload
    def isolation_level_str(self, isolation_level: _T) -> _T: ...

    def server_side_cursor(self, conn): ...

class Psycopg2Adapter(_BasePsycopgAdapter):
    json_type: Incomplete
    jsonb_type: Incomplete
    cast_json_case: bool
    def __init__(self) -> None: ...
    def check_driver(self) -> None: ...
    def get_binary_type(self) -> type[Incomplete]: ...
    def connect(self, db, **params): ...
    def get_server_version(self, conn): ...
    def is_connection_usable(self, conn) -> bool: ...
    def is_connection_reusable(self, conn) -> bool: ...
    def is_connection_closed(self, conn) -> bool: ...

class Psycopg3Adapter(_BasePsycopgAdapter):
    json_type: Incomplete
    jsonb_type: Incomplete
    cast_json_case: bool
    def __init__(self) -> None: ...
    def check_driver(self) -> None: ...
    def get_binary_type(self) -> type[Incomplete]: ...
    def connect(self, db, **params): ...
    def get_server_version(self, conn): ...
    def is_connection_usable(self, conn) -> bool: ...
    def is_connection_reusable(self, conn) -> bool: ...
    def is_connection_closed(self, conn) -> bool: ...

class PostgresqlDatabase(Database):
    field_types: Incomplete
    operations: Incomplete
    param: str
    compound_select_parentheses: Incomplete
    for_update: bool
    nulls_ordering: bool
    returning_clause: bool
    sequences: bool
    psycopg2_adapter: Incomplete
    psycopg3_adapter: Incomplete
    def init(
        self,
        database: str | None,
        register_unicode: bool = True,
        encoding=None,
        isolation_level=None,
        *,
        prefer_psycopg3: bool = False,
        **kwargs,
    ) -> None: ...
    def is_connection_usable(self) -> bool: ...
    def last_insert_id(self, cursor, query_type=None): ...
    def begin(self, isolation_level: str | None = None) -> None: ...
    def get_tables(self, schema: str | None = None) -> list[str]: ...
    def get_views(self, schema: str | None = None) -> list[ViewMetadata]: ...
    def get_indexes(self, table, schema: str | None = None) -> list[IndexMetadata]: ...
    def get_columns(self, table, schema: str | None = None) -> list[ColumnMetadata]: ...
    def get_primary_keys(self, table, schema: str | None = None) -> list[Incomplete]: ...
    def get_foreign_keys(self, table, schema: str | None = None) -> list[ForeignKeyMetadata]: ...
    def sequence_exists(self, sequence) -> bool: ...
    def get_binary_type(self) -> type[Incomplete]: ...
    def conflict_statement(self, on_conflict, query) -> None: ...
    def conflict_update(self, oc, query) -> NodeList: ...
    def extract_date(self, date_part, date_field) -> Function: ...
    def truncate_date(self, date_part, date_field) -> Function: ...
    def interval(self, val) -> NodeList: ...
    def to_timestamp(self, date_field) -> Function: ...
    def from_timestamp(self, date_field) -> Function: ...
    def get_noop_select(self, ctx): ...
    def set_time_zone(self, timezone) -> None: ...
    def set_isolation_level(self, isolation_level: int | str) -> None: ...

class MySQLDatabase(Database):
    field_types: Incomplete
    operations: Incomplete
    param: str
    quote: str
    compound_select_parentheses: Incomplete
    for_update: bool
    index_using_precedes_table: bool
    limit_max: Incomplete
    safe_create_index: bool
    safe_drop_index: bool
    sql_mode: str
    mariadb: bool
    def init(self, database: str | None, mariadb: bool | None = ..., **kwargs) -> None: ...
    def is_connection_usable(self) -> bool: ...
    def default_values_insert(self, ctx): ...
    def begin(self, isolation_level: str | None = None) -> None: ...
    def get_tables(self, schema: str | None = None) -> list[str]: ...
    def get_views(self, schema: str | None = None) -> list[ViewMetadata]: ...
    def get_indexes(self, table, schema: str | None = None) -> list[IndexMetadata]: ...
    def get_columns(self, table, schema: str | None = None) -> list[ColumnMetadata]: ...
    def get_primary_keys(self, table, schema: str | None = None) -> list[Incomplete]: ...
    def get_foreign_keys(self, table, schema: str | None = None) -> list[ForeignKeyMetadata]: ...
    def get_binary_type(self): ...
    def conflict_statement(self, on_conflict, query) -> SQL | None: ...
    def conflict_update(self, on_conflict, query) -> NodeList | None: ...
    def extract_date(self, date_part, date_field) -> Function: ...
    def truncate_date(self, date_part, date_field) -> Function: ...
    def to_timestamp(self, date_field) -> Function: ...
    def from_timestamp(self, date_field) -> Function: ...
    def random(self) -> Function: ...
    def get_noop_select(self, ctx): ...

class _manual(_callable_context_manager):
    db: Incomplete
    def __init__(self, db) -> None: ...
    def __enter__(self) -> None: ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...

class _atomic(_callable_context_manager):
    db: Incomplete
    def __init__(self, db, *args, **kwargs) -> None: ...
    def __enter__(self) -> _transaction | _savepoint: ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...

class _transaction(_callable_context_manager):
    db: Incomplete
    def __init__(self, db, *args, **kwargs) -> None: ...
    def commit(self, begin: bool = True) -> None: ...
    def rollback(self, begin: bool = True) -> None: ...
    def __enter__(self) -> Self: ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...

class _savepoint(_callable_context_manager):
    db: Incomplete
    sid: Incomplete
    quoted_sid: Incomplete
    def __init__(self, db, sid=None) -> None: ...
    def commit(self, begin: bool = True) -> None: ...
    def rollback(self, begin: bool = True) -> None: ...
    def __enter__(self) -> Self: ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...

class CursorWrapper:
    cursor: Incomplete
    count: int
    index: int
    initialized: bool
    populated: bool
    row_cache: list[Incomplete]
    def __init__(self, cursor) -> None: ...
    def __iter__(self): ...
    def __getitem__(self, item): ...
    def __len__(self) -> int: ...
    def initialize(self) -> None: ...
    def iterate(self, cache: bool = True): ...
    def process_row(self, row): ...
    def iterator(self) -> Generator[Incomplete]: ...
    def fill_cache(self, n: int = 0) -> None: ...
    def dedupe_columns(self, columns: Iterable[str], valid_identifiers: bool = True) -> list[str]: ...

class DictCursorWrapper(CursorWrapper):
    columns: list[str]
    ncols: int
    def initialize(self) -> None: ...
    def process_row(self, row): ...

class NamedTupleCursorWrapper(CursorWrapper):
    tuple_class: Incomplete
    def initialize(self) -> None: ...
    def process_row(self, row): ...

class ObjectCursorWrapper(DictCursorWrapper):
    constructor: Incomplete
    columns: list[str]
    ncols: int
    def __init__(self, cursor, constructor) -> None: ...
    def initialize(self) -> None: ...
    def process_row(self, row): ...

class ResultIterator:
    cursor_wrapper: Incomplete
    index: int
    def __init__(self, cursor_wrapper) -> None: ...
    def __iter__(self) -> Self: ...
    def next(self): ...
    __next__ = next

class FieldAccessor:
    model: Incomplete
    field: Incomplete
    name: Incomplete
    def __init__(self, model, field, name) -> None: ...
    def __get__(self, instance, instance_type=None): ...
    def __set__(self, instance, value) -> None: ...

class ForeignKeyAccessor(FieldAccessor):
    rel_model: Incomplete
    def __init__(self, model, field, name) -> None: ...
    def get_rel_instance(self, instance): ...
    def __get__(self, instance, instance_type=None): ...
    def __set__(self, instance, obj) -> None: ...

class BackrefAccessor:
    field: Incomplete
    model: Incomplete
    rel_model: Incomplete
    def __init__(self, field) -> None: ...
    def __get__(self, instance, instance_type=None): ...

class ObjectIdAccessor:
    field: Incomplete
    def __init__(self, field) -> None: ...
    def __get__(self, instance, instance_type=None): ...
    def __set__(self, instance, value) -> None: ...

class Field(ColumnBase, Generic[_V]):
    @overload
    def __get__(self, instance: None, owner: Any) -> Self: ...
    @overload
    def __get__(self, instance: object, owner: Any) -> _V: ...

    def __set__(self, instance: object, value: _V) -> None: ...
    accessor_class: Incomplete
    auto_increment: bool
    default_index_type: Incomplete
    field_type: ClassVar[str]
    null: Incomplete
    index: Incomplete
    unique: Incomplete
    column_name: Incomplete
    default: Incomplete
    primary_key: Incomplete
    constraints: Incomplete
    sequence: Incomplete
    collation: Incomplete
    unindexed: Incomplete
    choices: Incomplete
    help_text: Incomplete
    verbose_name: Incomplete
    index_type: Incomplete
    # Field constructor args are typed per-field in the __new__ overloads.
    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
    def __hash__(self) -> int: ...
    model: Incomplete
    name: Incomplete
    def bind(self, model, name, set_attribute: bool = True) -> None: ...
    @property
    def column(self) -> Column: ...
    def adapt(self, value): ...
    def db_value(self, value): ...
    def python_value(self, value): ...
    def to_value(self, value, case: bool = False) -> Value: ...
    def get_sort_key(self, ctx) -> tuple[Incomplete, ...]: ...
    def __sql__(self, ctx): ...
    def get_modifiers(self) -> list[int] | None: ...
    def ddl_datatype(self, ctx) -> SQL: ...
    def ddl(self, ctx) -> NodeList: ...

class AnyField(Field): ...

class IntegerField(Field[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> IntegerField[int | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> IntegerField[int]: ...

    def adapt(self, value): ...

class BigIntegerField(IntegerField[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> BigIntegerField[int | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> BigIntegerField[int]: ...

class SmallIntegerField(IntegerField[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> SmallIntegerField[int | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> SmallIntegerField[int]: ...

class AutoField(IntegerField[_V]):
    auto_increment: bool
    def __new__(cls, *args: Any, **kwargs: Unpack[_FieldKwargs]) -> AutoField[int]: ...

class BigAutoField(AutoField[_V]):
    def __new__(cls, *args: Any, **kwargs: Unpack[_FieldKwargs]) -> BigAutoField[int]: ...

class IdentityField(AutoField[_V]):
    def __new__(
        cls, *args: Any, generate_always: bool = ..., **kwargs: Unpack[_FieldKwargs]
    ) -> IdentityField[int]: ...

class PrimaryKeyField(AutoField[_V]):
    def __new__(cls, *args: Any, **kwargs: Unpack[_FieldKwargs]) -> PrimaryKeyField[int]: ...

class FloatField(Field[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> FloatField[float | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> FloatField[float]: ...

    def adapt(self, value): ...

class DoubleField(FloatField[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> DoubleField[float | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> DoubleField[float]: ...

class DecimalField(Field[_V]):
    max_digits: Incomplete
    decimal_places: Incomplete
    auto_round: Incomplete
    rounding: Incomplete

    @overload
    def __new__(
        cls,
        max_digits: int = ...,
        decimal_places: int = ...,
        auto_round: bool = ...,
        rounding: str | None = ...,
        *args: Any,
        null: Literal[True],
        **kwargs: Unpack[_FieldKwargs],
    ) -> DecimalField[Decimal | None]: ...
    @overload
    def __new__(
        cls,
        max_digits: int = ...,
        decimal_places: int = ...,
        auto_round: bool = ...,
        rounding: str | None = ...,
        *args: Any,
        null: Literal[False] = ...,
        **kwargs: Unpack[_FieldKwargs],
    ) -> DecimalField[Decimal]: ...

    def get_modifiers(self) -> list[int]: ...
    def db_value(self, value): ...
    def python_value(self, value) -> Decimal | None: ...

class _StringField(Field[_V]):
    def adapt(self, value) -> str: ...
    def __add__(self, other) -> StringExpression: ...
    def __radd__(self, other) -> StringExpression: ...

class CharField(_StringField[_V]):
    max_length: int

    @overload
    def __new__(
        cls, max_length: int = 255, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]
    ) -> CharField[str | None]: ...
    @overload
    def __new__(
        cls, max_length: int = 255, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]
    ) -> CharField[str]: ...

    def get_modifiers(self) -> list[int] | None: ...

class FixedCharField(CharField[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> FixedCharField[str | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> FixedCharField[str]: ...

    def adapt(self, value) -> str: ...

class TextField(_StringField[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> TextField[str | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> TextField[str]: ...

class FieldDatabaseHook:
    def bind(self, model, name, set_attribute: bool = True): ...

class BlobField(FieldDatabaseHook, Field[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> BlobField[bytes | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> BlobField[bytes]: ...

    def db_value(self, value): ...

class JSONPath(ColumnBase):
    def __init__(self, field, keys=..., as_text: bool = False) -> None: ...
    def __getitem__(self, key) -> JSONPath: ...
    def path(self, *keys) -> JSONPath: ...
    def as_text(self, as_text: bool = True) -> JSONPath: ...
    def as_int(self) -> Cast: ...
    def as_float(self) -> Cast: ...
    def set(self, value) -> Expression: ...
    def insert(self, value) -> Expression: ...
    def replace(self, value) -> Expression: ...
    def append(self, value) -> Expression: ...
    def remove(self) -> Expression: ...
    def length(self) -> Expression: ...
    def contained_by(self, value) -> Expression: ...
    def has_key(self, key) -> Expression: ...
    def has_keys(self, key_list) -> Expression: ...
    def has_any_keys(self, key_list) -> Expression: ...

class JSONField(FieldDatabaseHook, Field):
    def __init__(self, dumps=None, loads=None, **kwargs) -> None: ...
    def path(self, *keys): ...
    def length(self) -> Expression: ...
    def append(self, value) -> Expression: ...
    def update(self, value) -> Expression: ...
    def contains(self, value) -> Expression: ...  # type: ignore[override]
    def contained_by(self, value) -> Expression: ...
    def has_key(self, key) -> Expression: ...
    def has_keys(self, key_list) -> Expression: ...
    def has_any_keys(self, key_list) -> Expression: ...

class BitField(BitwiseMixin, BigIntegerField[_V]):
    def __new__(cls, *args: Any, **kwargs: Unpack[_FieldKwargs]) -> BitField[int]: ...
    def flag(self, value=None): ...

class BigBitFieldData:
    instance: Incomplete
    name: Incomplete
    def __init__(self, instance, name) -> None: ...
    def clear(self) -> None: ...
    def set_bit(self, idx) -> None: ...
    def clear_bit(self, idx) -> None: ...
    def toggle_bit(self, idx) -> bool: ...
    def is_set(self, idx) -> bool: ...
    __getitem__ = is_set
    def __setitem__(self, item: int, value: bool) -> None: ...
    __delitem__ = clear_bit
    def __len__(self) -> int: ...
    def __and__(self, other: BigBitFieldData | bytes | bytearray | memoryview) -> bytearray: ...
    def __or__(self, other: BigBitFieldData | bytes | bytearray | memoryview) -> bytearray: ...
    def __xor__(self, other: BigBitFieldData | bytes | bytearray | memoryview) -> bytearray: ...
    def __iter__(self) -> Iterator[Literal[0, 1]]: ...
    def __bytes__(self) -> bytes: ...

class BigBitFieldAccessor(FieldAccessor):
    def __get__(self, instance, instance_type=None): ...
    def __set__(self, instance, value) -> None: ...

class BigBitField(BlobField[bytes]):
    accessor_class: Incomplete
    def __new__(cls, *args: Any, **kwargs: Unpack[_FieldKwargs]) -> Self: ...

    @overload  # type: ignore[override]
    def __get__(self, instance: None, owner: Any) -> Self: ...
    @overload
    def __get__(self, instance: object, owner: Any) -> BigBitFieldData: ...

    def db_value(self, value): ...

class UUIDField(Field[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> UUIDField[UUID | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> UUIDField[UUID]: ...

    def db_value(self, value): ...
    def python_value(self, value) -> UUID | None: ...

class BinaryUUIDField(BlobField[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> BinaryUUIDField[UUID | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> BinaryUUIDField[UUID]: ...

    def db_value(self, value): ...
    def python_value(self, value) -> UUID | None: ...

class _BaseFormattedField(Field[_V]):
    formats: Incomplete
    def __init__(self, formats=None, *args, **kwargs) -> None: ...

class DateTimeField(_BaseFormattedField[_V]):
    @overload
    def __new__(
        cls, formats: list[str] | None = ..., *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]
    ) -> DateTimeField[datetime | None]: ...
    @overload
    def __new__(
        cls, formats: list[str] | None = ..., *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]
    ) -> DateTimeField[datetime]: ...

    formats: Incomplete
    def adapt(self, value): ...
    def to_timestamp(self): ...
    def truncate(self, part): ...
    @property
    def year(self): ...
    @property
    def month(self): ...
    @property
    def day(self): ...
    @property
    def hour(self): ...
    @property
    def minute(self): ...
    @property
    def second(self): ...

class DateField(_BaseFormattedField[_V]):
    @overload
    def __new__(
        cls, formats: list[str] | None = ..., *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]
    ) -> DateField[date | None]: ...
    @overload
    def __new__(
        cls, formats: list[str] | None = ..., *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]
    ) -> DateField[date]: ...

    formats: Incomplete
    def adapt(self, value): ...
    def to_timestamp(self): ...
    def truncate(self, part): ...
    @property
    def year(self): ...
    @property
    def month(self): ...
    @property
    def day(self): ...

class TimeField(_BaseFormattedField[_V]):
    @overload
    def __new__(
        cls, formats: list[str] | None = ..., *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]
    ) -> TimeField[time | None]: ...
    @overload
    def __new__(
        cls, formats: list[str] | None = ..., *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]
    ) -> TimeField[time]: ...

    formats: Incomplete
    def adapt(self, value): ...
    @property
    def hour(self): ...
    @property
    def minute(self): ...
    @property
    def second(self): ...

class TimestampField(BigIntegerField[_V]):
    valid_resolutions: Incomplete
    resolution: Incomplete
    ticks_to_microsecond: Incomplete
    utc: Incomplete
    formats: Incomplete

    @overload
    def __new__(
        cls, *args: Any, resolution: int = ..., utc: bool = ..., null: Literal[True], **kwargs: Unpack[_FieldKwargs]
    ) -> TimestampField[datetime | None]: ...
    @overload
    def __new__(
        cls, *args: Any, resolution: int = ..., utc: bool = ..., null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]
    ) -> TimestampField[datetime]: ...

    def get_timestamp(self, value) -> float: ...
    def db_value(self, value) -> int | None: ...
    def python_value(self, value): ...
    def from_timestamp(self): ...
    @property
    def year(self): ...
    @property
    def month(self): ...
    @property
    def day(self): ...
    @property
    def hour(self): ...
    @property
    def minute(self): ...
    @property
    def second(self): ...

class IPField(BigIntegerField[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> IPField[str | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> IPField[str]: ...

    def db_value(self, val): ...
    def python_value(self, val) -> str | None: ...

class BooleanField(Field[_V]):
    @overload
    def __new__(cls, *args: Any, null: Literal[True], **kwargs: Unpack[_FieldKwargs]) -> BooleanField[bool | None]: ...
    @overload
    def __new__(cls, *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FieldKwargs]) -> BooleanField[bool]: ...

    adapt: Incomplete

class BareField(Field):
    adapt: Incomplete
    def __init__(self, adapt=None, *args, **kwargs) -> None: ...
    def ddl_datatype(self, ctx): ...

class ForeignKeyField(Field[_V]):
    accessor_class: Incomplete
    backref_accessor_class: Incomplete
    rel_model: Incomplete
    rel_field: Incomplete
    declared_backref: Incomplete
    backref: Incomplete
    on_delete: Incomplete
    on_update: Incomplete
    deferrable: Incomplete
    deferred: Incomplete
    object_id_name: Incomplete
    lazy_load: Incomplete
    constraint_name: str | None

    @overload
    def __new__(
        cls, model: type[_M], *args: Any, null: Literal[True], **kwargs: Unpack[_FKKwargs]
    ) -> ForeignKeyField[_M | None]: ...
    @overload
    def __new__(
        cls, model: type[_M], *args: Any, null: Literal[False] = ..., **kwargs: Unpack[_FKKwargs]
    ) -> ForeignKeyField[_M]: ...
    @overload
    # Untyped fallback: model given as a name/"self"/deferred ref, so the related type isn't known.
    def __new__(cls, model: Any = ..., *args: Any, **kwargs: Unpack[_FKKwargs]) -> ForeignKeyField[Any]: ...

    @property
    def field_type(self): ...  # type: ignore[override]
    def get_modifiers(self): ...
    def adapt(self, value): ...
    def db_value(self, value): ...
    def python_value(self, value): ...
    column_name: Incomplete
    safe_name: Incomplete
    def bind(self, model, name, set_attribute: bool = True) -> None: ...
    def foreign_key_constraint(self, explicit_name: bool = False) -> NodeList: ...
    def get_constraint_name(self) -> str: ...
    def __getattr__(self, attr: str): ...

class DeferredForeignKey(Field):
    field_kwargs: Incomplete
    rel_model_name: Incomplete
    def __init__(self, rel_model_name, **kwargs) -> None: ...
    __hash__ = object.__hash__
    def __deepcopy__(self, memo=None) -> DeferredForeignKey: ...
    def set_model(self, rel_model) -> None: ...
    @staticmethod
    def resolve(model_cls) -> None: ...

class DeferredThroughModel:
    def __init__(self) -> None: ...
    def set_field(self, model, field, name) -> None: ...
    def set_model(self, through_model) -> None: ...

class MetaField(Field):
    column_name: Incomplete
    default: Incomplete
    model: Incomplete
    name: Incomplete
    primary_key: bool

class ManyToManyFieldAccessor(FieldAccessor):
    model: Incomplete
    rel_model: Incomplete
    through_model: Incomplete
    src_fk: Incomplete
    dest_fk: Incomplete
    def __init__(self, model, field, name) -> None: ...
    def __get__(self, instance, instance_type=None, force_query: bool = False): ...
    def __set__(self, instance, value) -> None: ...

class ManyToManyField(MetaField):
    accessor_class: Incomplete
    rel_model: Incomplete
    backref: Incomplete
    def __init__(
        self,
        model,
        backref=None,
        through_model=None,
        on_delete=None,
        on_update=None,
        prevent_unsaved: bool = True,
        _is_backref: bool = False,
    ) -> None: ...
    def bind(self, model, name, set_attribute: bool = True) -> None: ...
    def get_models(self) -> list[Incomplete]: ...

    @property
    def through_model(self): ...
    @through_model.setter
    def through_model(self, value) -> None: ...

    def get_through_model(self): ...

class VirtualField(MetaField):
    field_class: Incomplete
    field_instance: Incomplete
    def __init__(self, field_class=None, *args, **kwargs) -> None: ...
    def db_value(self, value): ...
    def python_value(self, value): ...
    model: Incomplete
    column_name: Incomplete
    def bind(self, model, name, set_attribute: bool = True) -> None: ...

class CompositeKey(MetaField):
    sequence: Incomplete
    field_names: Incomplete
    def __init__(self, *field_names) -> None: ...
    @property
    def safe_field_names(self): ...
    def __get__(self, instance, instance_type=None): ...
    def __set__(self, instance, value) -> None: ...
    def __eq__(self, other) -> Expression | bool: ...  # type: ignore[override]
    def __ne__(self, other) -> Expression | bool: ...  # type: ignore[override]
    def __hash__(self) -> int: ...
    def __sql__(self, ctx): ...
    model: Incomplete
    column_name: Incomplete
    def bind(self, model, name, set_attribute: bool = True) -> None: ...

class _SortedFieldList:
    __slots__ = ("_keys", "_items")
    def __init__(self) -> None: ...
    def __getitem__(self, i): ...
    def __iter__(self): ...
    def __contains__(self, item) -> bool: ...
    def index(self, field) -> int: ...
    def insert(self, item) -> None: ...
    def remove(self, item) -> None: ...

class SchemaManager:
    model: Incomplete
    context_options: Incomplete
    def __init__(self, model, database: _DatabaseType | None = None, **context_options) -> None: ...

    @property
    def database(self): ...
    @database.setter
    def database(self, value) -> None: ...

    def create_table(self, safe: bool = True, **options) -> None: ...
    def create_table_as(self, table_name, query, safe: bool = True, **meta) -> None: ...
    def drop_table(self, safe: bool = True, **options) -> None: ...
    def truncate_table(self, restart_identity: bool = False, cascade: bool = False) -> None: ...
    def create_indexes(self, safe: bool = True) -> None: ...
    def drop_index(self, field=None, index=None, safe: bool = True): ...
    def drop_indexes(self, safe: bool = True) -> None: ...
    def create_sequence(self, field) -> None: ...
    def drop_sequence(self, field) -> None: ...
    def create_foreign_key(self, field) -> None: ...
    def create_sequences(self) -> None: ...
    def create_all(self, safe: bool = True, **table_options) -> None: ...
    def drop_sequences(self) -> None: ...
    def drop_all(self, safe: bool = True, drop_sequences: bool = True, **options) -> None: ...

class Metadata:
    model: type[Model]
    database: Incomplete
    fields: Incomplete
    columns: Incomplete
    combined: Incomplete
    sorted_fields: Incomplete
    sorted_field_names: Incomplete
    defaults: Incomplete
    name: Incomplete
    table_function: Incomplete
    legacy_table_names: Incomplete
    table_name: Incomplete
    indexes: Incomplete
    constraints: Incomplete
    primary_key: Field[Any] | Literal[False]
    composite_key: Incomplete
    only_save_dirty: Incomplete
    depends_on: Incomplete
    table_settings: Incomplete
    without_rowid: Incomplete
    strict_tables: Incomplete
    temporary: Incomplete
    refs: Incomplete
    backrefs: Incomplete
    model_refs: Incomplete
    model_backrefs: Incomplete
    manytomany: Incomplete
    options: Incomplete
    def __init__(
        self,
        model,
        database: _DatabaseType | None = None,
        table_name=None,
        indexes=None,
        primary_key=None,
        constraints=None,
        schema: str | None = None,
        only_save_dirty: bool = False,
        depends_on=None,
        options=None,
        db_table=None,
        table_function=None,
        table_settings=None,
        without_rowid: bool = False,
        temporary: bool = False,
        strict_tables=None,
        legacy_table_names: bool = True,
        **kwargs,
    ) -> None: ...
    def make_table_name(self) -> str: ...
    def model_graph(
        self, refs: bool = True, backrefs: bool = True, depth_first: bool = True
    ) -> list[tuple[Incomplete, Incomplete, Incomplete]]: ...
    def add_ref(self, field) -> None: ...
    def remove_ref(self, field) -> None: ...
    def add_manytomany(self, field) -> None: ...
    def remove_manytomany(self, field) -> None: ...

    @property
    def table(self) -> Table: ...
    @table.deleter
    def table(self) -> None: ...

    @property
    def schema(self) -> str | None: ...
    @schema.setter
    def schema(self, value) -> None: ...

    @property
    def entity(self) -> Entity: ...
    def add_field(self, field_name, field, set_attribute: bool = True) -> None: ...
    def remove_field(self, field_name) -> None: ...
    auto_increment: Incomplete
    def set_primary_key(self, name, field) -> None: ...
    def get_primary_keys(self): ...
    def get_default_dict(self): ...
    def fields_to_index(self) -> list[Incomplete]: ...
    def set_database(self, database: _DatabaseType) -> None: ...
    def set_table_name(self, table_name) -> None: ...

class SubclassAwareMetadata(Metadata):
    models: Incomplete
    def __init__(self, model, *args, **kwargs) -> None: ...
    def map_models(self, fn) -> None: ...

class DoesNotExist(Exception): ...

class ModelBase(type):
    inheritable: set[str]
    def __new__(cls, name, bases, attrs): ...
    def __iter__(self): ...
    def __getitem__(self, key): ...
    def __setitem__(self, key, value) -> None: ...
    def __delitem__(self, key) -> None: ...
    def __contains__(self, key) -> bool: ...
    def __len__(self) -> int: ...
    def __bool__(self) -> bool: ...
    def __sql__(self, ctx): ...

class _BoundModelsContext(_callable_context_manager):
    models: Incomplete
    database: Incomplete
    bind_refs: Incomplete
    bind_backrefs: Incomplete
    def __init__(self, models, database: _DatabaseType, bind_refs, bind_backrefs) -> None: ...
    def __enter__(self): ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...

class Model(metaclass=ModelBase):
    __data__: Incomplete
    __rel__: Incomplete
    _meta: Metadata
    def __init__(self, *args, **kwargs) -> None: ...
    @classmethod
    def validate_model(cls) -> None: ...
    @classmethod
    def alias(cls, alias=None) -> ModelAlias[Self]: ...
    @classmethod
    def select(cls, *fields) -> ModelSelect[Self]: ...
    @classmethod
    def update(cls, data=None, /, **update) -> ModelUpdate: ...
    @classmethod
    def insert(cls, data=None, /, **insert) -> ModelInsert: ...
    @classmethod
    def insert_many(cls, rows, fields=None) -> ModelInsert: ...
    @classmethod
    def insert_from(cls, query, fields) -> ModelInsert: ...
    @classmethod
    def replace(cls, data=None, /, **insert): ...
    @classmethod
    def replace_many(cls, rows, fields=None): ...
    @classmethod
    def raw(cls, sql, *params) -> ModelRaw: ...
    @classmethod
    def delete(cls) -> ModelDelete: ...
    @classmethod
    def create(cls, **query) -> Self: ...
    @classmethod
    def bulk_create(cls, model_list, batch_size=None) -> None: ...
    @classmethod
    def bulk_update(cls, model_list, fields, batch_size=None): ...
    @classmethod
    def noop(cls) -> NoopModelSelect[Self]: ...
    @classmethod
    def get(cls, *query, **filters) -> Self: ...
    @classmethod
    def get_or_none(cls, *query, **filters) -> Self | None: ...
    @classmethod
    def get_by_id(cls, pk) -> Self: ...
    @classmethod
    def set_by_id(cls, key, value): ...
    @classmethod
    def delete_by_id(cls, pk): ...
    @classmethod
    def get_or_create(cls, **kwargs): ...
    @classmethod
    def filter(cls, *dq_nodes, **filters): ...
    def get_id(self): ...
    def save(self, force_insert: bool = False, only=None) -> int: ...
    def is_dirty(self) -> bool: ...
    @property
    def dirty_fields(self) -> list[Field[Any]]: ...
    @property
    def dirty_field_names(self) -> list[str]: ...
    def dependencies(self, search_nullable: bool = True, exclude_null_children: bool = False) -> Generator[Incomplete]: ...
    def delete_instance(self, recursive: bool = False, delete_nullable: bool = False) -> int: ...
    def __hash__(self) -> int: ...
    def __eq__(self, other) -> Expression | bool: ...  # type: ignore[override]
    def __ne__(self, other) -> Expression | bool: ...  # type: ignore[override]
    def __sql__(self, ctx): ...
    @classmethod
    def bind(cls, database: _DatabaseType, bind_refs: bool = True, bind_backrefs: bool = True, _exclude=None) -> bool: ...
    @classmethod
    def bind_ctx(cls, database: _DatabaseType, bind_refs: bool = True, bind_backrefs: bool = True) -> _BoundModelsContext: ...
    @classmethod
    def table_exists(cls): ...
    @classmethod
    def create_table(cls, safe: bool = True, **options) -> None: ...
    @classmethod
    def drop_table(cls, safe: bool = True, drop_sequences: bool = True, **options) -> None: ...
    @classmethod
    def truncate_table(cls, **options) -> None: ...
    @classmethod
    def index(cls, *fields, **kwargs) -> ModelIndex: ...
    @classmethod
    def add_index(cls, *fields, **kwargs) -> None: ...

class ModelAlias(Node, Generic[_M]):
    def __init__(self, model: type[_M], alias=None) -> None: ...
    def __getattr__(self, attr: str): ...
    def __setattr__(self, attr: str, value) -> None: ...
    def get_field_aliases(self) -> list[Incomplete]: ...
    def select(self, *selection) -> ModelSelect[_M]: ...
    def __call__(self, **kwargs): ...
    def __sql__(self, ctx): ...

class FieldAlias(Field):
    source: Incomplete
    model: Incomplete
    field: Incomplete
    def __init__(self, source, field) -> None: ...
    @classmethod
    def create(cls, source, field): ...
    def clone(self) -> FieldAlias: ...
    def adapt(self, value): ...
    def python_value(self, value): ...
    def db_value(self, value): ...
    def __getattr__(self, attr: str): ...
    def __sql__(self, ctx): ...

class _ModelQueryHelper:
    default_row_type: Incomplete
    def __init__(self, *args, **kwargs) -> None: ...
    def objects(self, constructor=None) -> Self: ...
    def models(self) -> Self: ...

class ModelRaw(_ModelQueryHelper, RawQuery):  # type: ignore[misc]
    model: Incomplete
    def __init__(self, model, sql, params, **kwargs) -> None: ...
    def get(self) -> Model: ...

class BaseModelSelect(_ModelQueryHelper):
    def union_all(self, rhs) -> ModelCompoundSelectQuery: ...
    __add__ = union_all
    def union(self, rhs) -> ModelCompoundSelectQuery: ...
    __or__ = union
    def intersect(self, rhs) -> ModelCompoundSelectQuery: ...
    __and__ = intersect
    def except_(self, rhs) -> ModelCompoundSelectQuery: ...
    __sub__ = except_
    def __iter__(self): ...
    def prefetch(self, *subqueries, prefetch_type: int = ...): ...
    def with_related(
        self, *loads: Load | ForeignKeyField[Any] | BackrefAccessor
    ) -> Self: ...
    def iterator(self, database: _DatabaseType | None = ...) -> Iterator[Any]: ...
    def get(self, database: _DatabaseType | None = None): ...
    def get_or_none(self, database: _DatabaseType | None = None): ...
    def group_by(self, *columns) -> Self: ...

class ModelCompoundSelectQuery(BaseModelSelect, CompoundSelectQuery):  # type: ignore[misc]
    model: Incomplete
    def __init__(self, model, *args, **kwargs) -> None: ...

class ModelSelect(BaseModelSelect, Select, Generic[_M]):  # type: ignore[misc]
    model: type[_M]
    def __init__(self, model, fields_or_models, is_default: bool = False) -> None: ...
    def __iter__(self) -> Iterator[_M]: ...
    def get(self, database: _DatabaseType | None = None) -> _M: ...
    def get_or_none(self, database: _DatabaseType | None = None) -> _M | None: ...
    def clone(self) -> Self: ...
    def select(self, *fields_or_models) -> ModelSelect[_M]: ...
    def select_extend(self, *columns) -> Self: ...
    def switch(self, ctx=None) -> Self: ...
    def join(self, dest, join_type="INNER JOIN", on=None, src=None, attr=None) -> Self: ...  # type: ignore[override]
    def left_outer_join(self, dest, on=None, src=None, attr=None) -> Self: ...  # type: ignore[override]
    def join_from(self, src, dest, join_type="INNER JOIN", on=None, attr=None) -> Self: ...
    def ensure_join(self, lm, rm, on=None, **join_kwargs): ...
    def convert_dict_to_node(self, qdict) -> tuple[list[Incomplete], list[Incomplete]]: ...
    def filter(self, *args, **kwargs) -> Self: ...
    def create_table(self, name, safe: bool = True, **meta): ...
    def __sql_selection__(self, ctx, is_subquery: bool = False): ...

class NoopModelSelect(ModelSelect[_M]):
    def __sql__(self, ctx): ...

class _ModelWriteQueryHelper(_ModelQueryHelper):
    model: Incomplete
    def __init__(self, model, *args, **kwargs) -> None: ...
    def returning(self, *returning) -> Self: ...

class ModelUpdate(_ModelWriteQueryHelper, Update): ...  # type: ignore[misc]

class ModelInsert(_ModelWriteQueryHelper, Insert):  # type: ignore[misc]
    default_row_type: Incomplete
    def __init__(self, *args, **kwargs) -> None: ...
    def returning(self, *returning) -> Self: ...
    def get_default_data(self): ...
    def get_default_columns(self): ...

class ModelDelete(_ModelWriteQueryHelper, Delete): ...  # type: ignore[misc]

class ManyToManyQuery(ModelSelect[_M]):
    def __init__(self, instance, accessor, rel, *args, **kwargs) -> None: ...
    def add(self, value, clear_existing: bool = False) -> None: ...
    def remove(self, value): ...
    def clear(self): ...

class BaseModelCursorWrapper(DictCursorWrapper):
    model: Incomplete
    select: Incomplete
    ncols: int
    columns: list[str]
    converters: list[Incomplete]
    fields: list[Incomplete]
    no_convert: list[int]
    convert: list[int]
    def __init__(self, cursor, model, columns) -> None: ...
    def initialize(self) -> None: ...
    def process_row(self, row): ...

class ModelDictCursorWrapper(BaseModelCursorWrapper):
    unique_columns: list[str]
    def initialize(self) -> None: ...
    def process_row(self, row) -> dict[str, Incomplete]: ...

class ModelTupleCursorWrapper(BaseModelCursorWrapper):
    constructor: Incomplete
    def process_row(self, row) -> tuple[Incomplete, ...]: ...  # type: ignore[override]

class ModelNamedTupleCursorWrapper(ModelTupleCursorWrapper):
    impl: Incomplete
    constructor: Incomplete
    def initialize(self) -> None: ...

class ModelObjectCursorWrapper(ModelDictCursorWrapper):
    constructor: Incomplete
    is_model: Incomplete
    identifiers: list[str]
    def __init__(self, cursor, model, select, constructor) -> None: ...
    def initialize(self) -> None: ...
    def process_row(self, row): ...

class ModelCursorWrapper(BaseModelCursorWrapper):
    from_list: Incomplete
    joins: Incomplete
    def __init__(self, cursor, model, select, from_list, joins) -> None: ...
    key_to_constructor: Incomplete
    src_to_dest: list[tuple[Incomplete, Incomplete, Incomplete, bool, Incomplete, bool]]
    column_keys: list[Incomplete]
    def initialize(self) -> None: ...
    def process_row(self, row): ...

@type_check_only
class _PrefetchQuery(NamedTuple):
    query: Incomplete
    fields: Incomplete
    is_backref: bool
    rel_models: Incomplete
    field_to_name: Incomplete
    model: Incomplete

class PrefetchQuery(_PrefetchQuery):
    def __new__(
        cls, query, fields=None, is_backref: bool | None = None, rel_models=None, field_to_name=None
    ) -> Self: ...
    def populate_instance(self, instance, id_map) -> None: ...
    def store_instance(self, instance, id_map) -> None: ...

def prefetch(sq, *subqueries, prefetch_type: int = ...): ...

class Load(Node):
    def __init__(
        self,
        rel: ForeignKeyField[Any] | BackrefAccessor,
        query: ModelSelect[Any] | None = ...,
        strategy: int = ...,
        per_parent: int | None = ...,
    ) -> None: ...
    def then(
        self, *children: Load | ForeignKeyField[Any] | BackrefAccessor
    ) -> Self: ...

__all__ = [
    "AnyField",
    "AsIs",
    "AutoField",
    "BareField",
    "BigAutoField",
    "BigBitField",
    "BigIntegerField",
    "BinaryUUIDField",
    "BitField",
    "BlobField",
    "BooleanField",
    "Case",
    "Cast",
    "CharField",
    "Check",
    "chunked",
    "Column",
    "CompositeKey",
    "Context",
    "Database",
    "DatabaseError",
    "DatabaseProxy",
    "DataError",
    "DateField",
    "DateTimeField",
    "DecimalField",
    "Default",
    "DeferredForeignKey",
    "DeferredThroughModel",
    "DJANGO_MAP",
    "DoesNotExist",
    "DoubleField",
    "DQ",
    "Entity",
    "EXCLUDED",
    "Field",
    "FixedCharField",
    "FloatField",
    "fn",
    "ForeignKeyField",
    "IdentityField",
    "ImproperlyConfigured",
    "Index",
    "IntegerField",
    "IntegrityError",
    "InterfaceError",
    "InternalError",
    "IPField",
    "JOIN",
    "JSONField",
    "Load",
    "ManyToManyField",
    "Model",
    "ModelIndex",
    "MySQLDatabase",
    "NotSupportedError",
    "OP",
    "OperationalError",
    "PostgresqlDatabase",
    "PrimaryKeyField",
    "prefetch",
    "PREFETCH_TYPE",
    "ProgrammingError",
    "Proxy",
    "QualifiedNames",
    "SchemaManager",
    "SmallIntegerField",
    "Select",
    "SQL",
    "SqliteDatabase",
    "Table",
    "TextField",
    "TimeField",
    "TimestampField",
    "Tuple",
    "UUIDField",
    "Value",
    "ValuesList",
    "Window",
]