import itertools
import logging
import threading
from _typeshed import Incomplete, SupportsKeysAndGetItem
from collections.abc import Callable, Generator, Iterable, Iterator
from types import TracebackType
from typing import Any, ClassVar, Literal, NamedTuple, TypeVar
from typing_extensions import Self

class NullHandler(logging.Handler):
    def emit(self, record) -> None: ...

text_type = str
bytes_type = bytes
buffer_type = memoryview
basestring = str
long = int
izip_longest = itertools.zip_longest

_VT = TypeVar("_VT")
_F = TypeVar("_F", bound=Callable[..., Any])

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]
PREFETCH_TYPE: attrdict[int]

def chunked(it, n) -> Generator[Incomplete, None, None]: ...

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

class Proxy:
    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):
    def connection_context(self): ...
    def atomic(self, *args, **kwargs): ...
    def manual_commit(self): ...
    def transaction(self, *args, **kwargs): ...
    def savepoint(self): ...
    @property
    def Model(self) -> type[Model]: ...

class ModelDescriptor: ...

class AliasManager:
    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): ...
    def __call__(self, scope=None, parentheses=None, **kwargs): ...
    def __getattr__(self, attr_name: str): ...

class Context:
    stack: Incomplete
    alias_manager: Incomplete
    state: Incomplete
    def __init__(self, **settings) -> None: ...
    def as_new(self): ...
    def column_sort_key(self, item): ...
    @property
    def scope(self): ...
    @property
    def parentheses(self): ...
    @property
    def subquery(self): ...
    def __call__(self, **overrides): ...
    scope_normal: Incomplete
    scope_source: Incomplete
    scope_values: Incomplete
    scope_cte: Incomplete
    scope_column: Incomplete
    def __enter__(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): ...
    def value(self, value, converter=None, add_param: bool = True): ...
    def __sql__(self, ctx): ...
    def parse(self, node): ...
    def query(self): ...

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

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

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

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

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): ...
    @property
    def __star__(self) -> Star: ...
    def join(self, dest, join_type="INNER JOIN", on=None): ...
    def left_outer_join(self, dest, on=None): ...
    def cte(self, name, recursive: bool = False, columns=None, materialized=None): ...
    def get_sort_key(self, ctx): ...
    def apply_alias(self, ctx): ...
    def apply_column(self, ctx): ...

class _HashableSource:
    def __init__(self, *args, **kwargs) -> None: ...
    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):
    __and__: Incomplete
    __add__: Incomplete
    __sub__: Incomplete
    __or__: Incomplete
    __mul__: Incomplete
    __rand__: Incomplete
    __radd__: Incomplete
    __rsub__: Incomplete
    __ror__: Incomplete
    __rmul__: Incomplete

class _BoundTableContext(_callable_context_manager):
    table: Incomplete
    database: Incomplete
    def __init__(self, table, database) -> 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): ...
    def bind(self, database=None): ...
    def bind_ctx(self, database=None): ...
    def select(self, *columns): ...
    def insert(self, insert=None, columns=None, **kwargs): ...
    def replace(self, insert=None, columns=None, **kwargs): ...
    def update(self, update=None, **kwargs): ...
    def delete(self): ...
    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): ...
    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): ...
    def union_all(self, rhs): ...
    __add__: Incomplete
    def union(self, rhs): ...
    __or__: Incomplete
    def __sql__(self, ctx): ...

class ColumnBase(Node):
    def converter(self, converter=None) -> Self: ...
    def alias(self, alias): ...
    def unalias(self): ...
    def bind_to(self, dest): ...
    def cast(self, as_type): ...
    def asc(self, collation=None, nulls=None): ...
    __pos__: Incomplete
    def desc(self, collation=None, nulls=None): ...
    __neg__: Incomplete
    def __invert__(self): ...
    __and__: Incomplete
    __or__: Incomplete
    def __add__(self, rhs: Any) -> Expression: ...
    __sub__: Incomplete
    __mul__: ClassVar[Callable[[Self, Any], Expression]]
    __div__: 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]]
    __rdiv__: 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): ...
    def __getitem__(self, item): ...
    __iter__: Incomplete
    def distinct(self): ...
    def collate(self, collation): ...
    def get_sort_key(self, ctx): ...

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

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

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

class _DynamicEntity:
    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): ...
    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): ...
    def __or__(self, other): ...
    def __sub__(self, other): ...
    def __invert__(self): ...

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

class Value(ColumnBase):
    value: Incomplete
    converter: Incomplete
    multi: Incomplete
    values: Incomplete
    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): ...
    def __sql__(self, ctx): ...

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

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

class Entity(ColumnBase):
    def __init__(self, *path) -> None: ...
    def __getattr__(self, attr: str): ...
    def get_sort_key(self, ctx): ...
    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, name=None): ...

class Function(ColumnBase):
    no_coerce_functions: ClassVar[set[str]]
    name: Incomplete
    arguments: Incomplete
    def __init__(self, name, arguments, coerce: bool = True, python_value=None) -> None: ...
    def __getattr__(self, attr: str): ...
    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): ...
    def __sql__(self, ctx): ...

fn: Incomplete

class Window(Node):
    CURRENT_ROW: Incomplete
    GROUP: Incomplete
    TIES: Incomplete
    NO_OTHERS: Incomplete
    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): ...
    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): ...
    @staticmethod
    def preceding(value=None): ...
    def __sql__(self, ctx): ...

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

class ForUpdate(Node):
    def __init__(self, expr, of=None, nowait=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: Incomplete
    def __init__(self, nodes, glue: str = " ", parens: bool = False) -> None: ...
    def __sql__(self, ctx): ...

class _Namespace(Node):
    def __init__(self, name) -> None: ...
    def __getattr__(self, attr: str): ...
    __getitem__: Incomplete

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: ...
    def clone(self): ...

Tuple: Incomplete

class QualifiedNames(WrappedNode):
    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=None): ...
    def clone(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): ...
    def execute(self, database=None): ...
    def iterator(self, database=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):
    union_all: Incomplete
    __add__: Incomplete
    union: Incomplete
    __or__: Incomplete
    intersect: Incomplete
    __and__: Incomplete
    except_: Incomplete
    __sub__: Incomplete
    __radd__: Incomplete
    __ror__: Incomplete
    __rand__: Incomplete
    __rsub__: Incomplete
    def select_from(self, *columns): ...

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

class CompoundSelectQuery(SelectBase):
    lhs: Incomplete
    op: Incomplete
    rhs: Incomplete
    def __init__(self, lhs, op, rhs) -> None: ...
    def exists(self, database=None): ...
    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,
        for_update_of=None,
        nowait=None,
        lateral=None,
        **kwargs,
    ) -> None: ...
    def clone(self): ...
    def columns(self, *columns, **kwargs) -> Self: ...
    select: Incomplete
    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: ...
    def left_outer_join(self, dest, on=None): ...
    def group_by(self, *columns) -> Self: ...
    def group_by_extend(self, *values): ...
    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=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): ...
    def returning(self, *returning) -> Self: ...
    def apply_returning(self, ctx): ...
    def execute_returning(self, database): ...
    def handle_result(self, database, 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) -> None: ...  # type: ignore[override]
    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): ...
    def __sql__(self, ctx): ...
    def handle_result(self, database, 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:
    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

class ForeignKeyMetadata(NamedTuple):
    column: Incomplete
    dest_table: Incomplete
    dest_column: Incomplete
    table: Incomplete

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:
    def __enter__(self): ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...

class ConnectionContext(_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 Database(_callable_context_manager):
    context_class: Incomplete
    field_types: Incomplete
    operations: Incomplete
    param: str
    quote: str
    server_version: Incomplete
    commit_select: bool
    compound_select_parentheses: Incomplete
    for_update: bool
    index_schema_prefix: bool
    index_using_precedes_table: 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 __init__(
        self,
        database,
        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, **kwargs) -> None: ...
    def __enter__(self): ...
    def __exit__(
        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
    ) -> None: ...
    def connection_context(self): ...
    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): ...
    def get_sql_context(self, **context_options): ...
    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): ...
    def session_commit(self): ...
    def session_rollback(self): ...
    def in_transaction(self): ...
    def push_transaction(self, transaction) -> None: ...
    def pop_transaction(self): ...
    def transaction_depth(self): ...
    def top_transaction(self): ...
    def atomic(self, *args, **kwargs): ...
    def manual_commit(self): ...
    def transaction(self, *args, **kwargs): ...
    def savepoint(self): ...
    def begin(self) -> None: ...
    def commit(self): ...
    def rollback(self): ...
    def batch_commit(self, it, n) -> Generator[Incomplete, None, None]: ...
    def table_exists(self, table_name, schema: str | None = None): ...
    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) -> 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): ...
    def get_noop_select(self, ctx): ...
    @property
    def Model(self) -> type[Model]: ...

class SqliteDatabase(Database):
    field_types: Incomplete
    operations: Incomplete
    index_schema_prefix: bool
    limit_max: int
    server_version: Incomplete
    truncate_table: bool
    nulls_ordering: bool
    def __init__(self, database, regexp_function: bool = False, *args, **kwargs) -> None: ...
    returning_clause: Incomplete
    def init(self, database, 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): ...
    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): ...
    def detach(self, name): ...
    def last_insert_id(self, cursor, query_type=None): ...
    def rows_affected(self, cursor): ...
    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): ...
    def get_foreign_keys(self, table, schema: str | None = None) -> list[ForeignKeyMetadata]: ...
    def get_binary_type(self): ...
    def conflict_statement(self, on_conflict, query): ...
    def conflict_update(self, oc, query): ...
    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): ...

class Psycopg2Adapter:
    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: ...
    def extract_date(self, date_part, date_field) -> Function: ...

class Psycopg3Adapter:
    json_type: Incomplete
    jsonb_type: Incomplete
    cast_json_case: bool
    def __init__(self): ...
    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: ...
    def extract_date(self, date_part, date_field) -> Function: ...

class PostgresqlDatabase(Database):
    field_types: Incomplete
    operations: Incomplete
    param: str
    commit_select: bool
    compound_select_parentheses: Incomplete
    for_update: bool
    nulls_ordering: bool
    returning_clause: bool
    safe_create_index: bool
    sequences: bool
    psycopg2_adapter: Incomplete
    psycopg3_adapter: Incomplete
    def init(
        self,
        database,
        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 rows_affected(self, cursor): ...
    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): ...
    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 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: ...

class MySQLDatabase(Database):
    field_types: Incomplete
    operations: Incomplete
    param: str
    quote: str
    commit_select: bool
    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
    def init(self, database, **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): ...
    def get_foreign_keys(self, table, schema: str | None = None) -> list[ForeignKeyMetadata]: ...
    def get_binary_type(self): ...
    def conflict_statement(self, on_conflict, query): ...
    def conflict_update(self, on_conflict, query): ...
    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 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): ...
    def __exit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | 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): ...
    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) -> None: ...
    def __enter__(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: 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, None, None]: ...
    def fill_cache(self, n: int = 0) -> None: ...

class DictCursorWrapper(CursorWrapper):
    initialize: Incomplete
    process_row: Incomplete

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

class ObjectCursorWrapper(DictCursorWrapper):
    constructor: Incomplete
    def __init__(self, cursor, constructor) -> None: ...
    def process_row(self, row): ...

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

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):
    accessor_class: Incomplete
    auto_increment: bool
    default_index_type: Incomplete
    field_type: ClassVar[str]
    unpack: bool
    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
    def __init__(
        self,
        null: bool = False,
        index: bool = False,
        unique: bool = False,
        column_name=None,
        default=None,
        primary_key: bool = False,
        constraints=None,
        sequence=None,
        collation=None,
        unindexed: bool = False,
        choices=None,
        help_text=None,
        verbose_name=None,
        index_type=None,
        db_column=None,
        _hidden: bool = False,
    ) -> None: ...
    def __hash__(self) -> int: ...
    model: Incomplete
    name: Incomplete
    def bind(self, model, name, set_attribute: bool = True) -> None: ...
    @property
    def column(self): ...
    def adapt(self, value): ...
    def db_value(self, value): ...
    def python_value(self, value): ...
    def to_value(self, value, case: bool = False): ...
    def get_sort_key(self, ctx): ...
    def __sql__(self, ctx): ...
    def get_modifiers(self) -> None: ...
    def ddl_datatype(self, ctx): ...
    def ddl(self, ctx): ...

class AnyField(Field): ...

class IntegerField(Field):
    def adapt(self, value): ...

class BigIntegerField(IntegerField): ...
class SmallIntegerField(IntegerField): ...

class AutoField(IntegerField):
    auto_increment: bool
    def __init__(self, *args, **kwargs) -> None: ...

class BigAutoField(AutoField): ...

class IdentityField(AutoField):
    def __init__(self, generate_always: bool = False, **kwargs) -> None: ...

class PrimaryKeyField(AutoField):
    def __init__(self, *args, **kwargs) -> None: ...

class FloatField(Field):
    def adapt(self, value): ...

class DoubleField(FloatField): ...

class DecimalField(Field):
    max_digits: Incomplete
    decimal_places: Incomplete
    auto_round: Incomplete
    rounding: Incomplete
    def __init__(
        self, max_digits: int = 10, decimal_places: int = 5, auto_round: bool = False, rounding=None, *args, **kwargs
    ) -> None: ...
    def get_modifiers(self): ...
    def db_value(self, value): ...
    def python_value(self, value): ...

class _StringField(Field):
    def adapt(self, value): ...
    def __add__(self, other): ...
    def __radd__(self, other): ...

class CharField(_StringField):
    max_length: Incomplete
    def __init__(self, max_length: int = 255, *args, **kwargs) -> None: ...
    def get_modifiers(self): ...

class FixedCharField(CharField):
    def python_value(self, value): ...

class TextField(_StringField): ...

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

class BlobField(FieldDatabaseHook, Field):
    def db_value(self, value): ...

class BitField(BitwiseMixin, BigIntegerField):
    def __init__(self, *args, **kwargs) -> None: ...
    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): ...
    def is_set(self, idx): ...
    __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):
    accessor_class: Incomplete
    def __init__(self, *args, **kwargs) -> None: ...
    def db_value(self, value): ...

class UUIDField(Field):
    def db_value(self, value): ...
    def python_value(self, value): ...

class BinaryUUIDField(BlobField):
    def db_value(self, value): ...
    def python_value(self, value): ...

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

class DateTimeField(_BaseFormattedField):
    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):
    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):
    formats: Incomplete
    def adapt(self, value): ...
    @property
    def hour(self): ...
    @property
    def minute(self): ...
    @property
    def second(self): ...

class TimestampField(BigIntegerField):
    valid_resolutions: Incomplete
    resolution: Incomplete
    ticks_to_microsecond: Incomplete
    utc: Incomplete
    def __init__(self, *args, **kwargs) -> None: ...
    def local_to_utc(self, dt): ...
    def utc_to_local(self, dt): ...
    def get_timestamp(self, value): ...
    def db_value(self, value): ...
    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):
    def db_value(self, val): ...
    def python_value(self, val): ...

class BooleanField(Field):
    adapt: Incomplete

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

class ForeignKeyField(Field):
    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
    def __init__(
        self,
        model,
        field=None,
        backref=None,
        on_delete=None,
        on_update=None,
        deferrable=None,
        _deferred=None,
        rel_model=None,
        to_field=None,
        object_id_name=None,
        lazy_load: bool = True,
        constraint_name: str | None = None,
        related_name=None,
        *args,
        **kwargs,
    ) -> None: ...
    @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__: Incomplete
    def __deepcopy__(self, memo=None): ...
    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): ...
    @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:
    def __init__(self) -> None: ...
    def __getitem__(self, i): ...
    def __iter__(self): ...
    def __contains__(self, item): ...
    def index(self, field): ...
    def insert(self, item) -> None: ...
    def remove(self, item) -> None: ...

class SchemaManager:
    model: Incomplete
    context_options: Incomplete
    def __init__(self, model, database=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_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: Incomplete
    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: Incomplete
    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=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): ...
    def model_graph(self, refs: bool = True, backrefs: bool = True, depth_first: bool = True): ...
    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.deleter
    def table(self) -> None: ...
    @property
    def schema(self): ...
    @schema.setter
    def schema(self, value) -> None: ...
    @property
    def entity(self): ...
    def get_rel_for_model(self, model): ...
    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): ...
    def set_database(self, database) -> 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: Incomplete
    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): ...
    def __len__(self) -> int: ...
    def __bool__(self) -> bool: ...
    def __nonzero__(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, 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
    def __init__(self, *args, **kwargs) -> None: ...
    @classmethod
    def validate_model(cls) -> None: ...
    @classmethod
    def alias(cls, alias=None): ...
    @classmethod
    def select(cls, *fields): ...
    @classmethod
    def update(cls, data=None, /, **update): ...
    @classmethod
    def insert(cls, data=None, /, **insert): ...
    @classmethod
    def insert_many(cls, rows, fields=None): ...
    @classmethod
    def insert_from(cls, query, fields): ...
    @classmethod
    def replace(cls, data=None, /, **insert): ...
    @classmethod
    def replace_many(cls, rows, fields=None): ...
    @classmethod
    def raw(cls, sql, *params): ...
    @classmethod
    def delete(cls): ...
    @classmethod
    def create(cls, **query): ...
    @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): ...
    @classmethod
    def get(cls, *query, **filters): ...
    @classmethod
    def get_or_none(cls, *query, **filters): ...
    @classmethod
    def get_by_id(cls, pk): ...
    @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): ...
    def is_dirty(self) -> bool: ...
    @property
    def dirty_fields(self): ...
    @property
    def dirty_field_names(self) -> list[Incomplete]: ...
    def dependencies(
        self, search_nullable: bool = True, exclude_null_children: bool = False
    ) -> Generator[Incomplete, None, None]: ...
    def delete_instance(self, recursive: bool = False, delete_nullable: bool = False): ...
    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, bind_refs: bool = True, bind_backrefs: bool = True, _exclude=None): ...
    @classmethod
    def bind_ctx(cls, database, bind_refs: bool = True, bind_backrefs: bool = True): ...
    @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): ...
    @classmethod
    def add_index(cls, *fields, **kwargs) -> None: ...

class ModelAlias(Node):
    def __init__(self, model, alias=None) -> None: ...
    def __getattr__(self, attr: str): ...
    def __setattr__(self, attr: str, value) -> None: ...
    def get_field_aliases(self): ...
    def select(self, *selection): ...
    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): ...
    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: ...

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

class BaseModelSelect(_ModelQueryHelper):
    def union_all(self, rhs): ...
    __add__: Incomplete
    def union(self, rhs): ...
    __or__: Incomplete
    def intersect(self, rhs): ...
    __and__: Incomplete
    def except_(self, rhs): ...
    __sub__: Incomplete
    def __iter__(self): ...
    def prefetch(self, *subqueries): ...
    def get(self, database=None): ...
    def get_or_none(self, database=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):  # type: ignore[misc]
    model: Incomplete
    def __init__(self, model, fields_or_models, is_default: bool = False) -> None: ...
    def clone(self): ...
    def select(self, *fields_or_models): ...
    def select_extend(self, *columns): ...
    def switch(self, ctx=None): ...
    def join(self, dest, join_type="INNER JOIN", on=None, src=None, attr=None) -> Self: ...
    def left_outer_join(self, dest, on=None, src=None, attr=None): ...
    def join_from(self, src, dest, join_type="INNER JOIN", on=None, attr=None): ...
    def ensure_join(self, lm, rm, on=None, **join_kwargs): ...
    def convert_dict_to_node(self, qdict): ...
    def filter(self, *args, **kwargs): ...
    def create_table(self, name, safe: bool = True, **meta): ...
    def __sql_selection__(self, ctx, is_subquery: bool = False): ...

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

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

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): ...
    def get_default_data(self): ...
    def get_default_columns(self): ...

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

class ManyToManyQuery(ModelSelect):
    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
    def __init__(self, cursor, model, columns) -> None: ...
    initialize: Incomplete
    def process_row(self, row) -> None: ...

class ModelDictCursorWrapper(BaseModelCursorWrapper):
    def process_row(self, row): ...

class ModelTupleCursorWrapper(ModelDictCursorWrapper):
    constructor: Incomplete
    def process_row(self, row): ...

class ModelNamedTupleCursorWrapper(ModelTupleCursorWrapper):
    tuple_class: Incomplete
    constructor: Incomplete
    def initialize(self): ...

class ModelObjectCursorWrapper(ModelDictCursorWrapper):
    constructor: Incomplete
    is_model: Incomplete
    def __init__(self, cursor, model, select, constructor) -> 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_is_dest: Incomplete
    src_to_dest: Incomplete
    column_keys: Incomplete
    def initialize(self) -> None: ...
    def process_row(self, row): ...

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

def prefetch(sq, *subqueries): ...

__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",
    "DeferredForeignKey",
    "DeferredThroughModel",
    "DJANGO_MAP",
    "DoesNotExist",
    "DoubleField",
    "DQ",
    "EXCLUDED",
    "Field",
    "FixedCharField",
    "FloatField",
    "fn",
    "ForeignKeyField",
    "IdentityField",
    "ImproperlyConfigured",
    "Index",
    "IntegerField",
    "IntegrityError",
    "InterfaceError",
    "InternalError",
    "IPField",
    "JOIN",
    "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",
]