from collections import MutableMapping
from typing import Any, Dict, Generator, List, TypeVar

from . import api, fields
from .api import Environment
from .modules.registry import Registry
from .sql_db import Cursor

_ModelT = TypeVar("_ModelT", bound=BaseModel)

_logger: Any
_schema: Any
_unlink: Any
regex_order: Any
regex_object_name: Any
regex_pg_name: Any
onchange_v7: Any
AUTOINIT_RECALCULATE_STORED_FIELDS: int

def check_object_name(name): ...
def raise_on_invalid_object_name(name) -> None: ...
def check_pg_name(name) -> None: ...

regex_private: Any

def check_method_name(name) -> None: ...

POSTGRES_CONFDELTYPES: Any

def intersect(la, lb): ...
def same_name(f, g): ...
def fix_import_export_id_paths(fieldname): ...

class MetaModel(api.Meta):
    module_to_models: Any
    _register: bool
    _module: Any
    def __init__(self, name, bases, attrs) -> None: ...
    def _get_addon_name(self, full_name): ...

class NewId:
    def __nonzero__(self): ...

IdType: Any
PREFETCH_MAX: int
LOG_ACCESS_COLUMNS: Any
MAGIC_COLUMNS: Any

class BaseModel:
    __metaclass__: MetaModel
    _auto: bool
    _register: bool
    _abstract: bool
    _transient: bool
    _name: Any
    _description: Any
    _custom: bool
    _inherit: Any
    _inherits: Any
    _constraints: Any
    _table: Any
    _sequence: Any
    _sql_constraints: Any
    _rec_name: Any
    _order: str
    _parent_name: str
    _parent_store: bool
    _parent_order: bool
    _date_name: str
    _fold_name: str
    _needaction: bool
    _translate: bool
    _depends: Any
    _transient_check_count: int
    _transient_max_count: Any
    _transient_max_hours: Any
    _fields: Dict[str, fields.Field]
    _ids: tuple
    env: Environment = ...
    pool: Registry
    id = fields.Id()
    display_name = fields.Char()
    create_uid = fields.Many2one("res.users")
    create_date = fields.Datetime()
    write_uid = fields.Many2one("res.users")
    write_date = fields.Datetime()
    CONCURRENCY_CHECK_FIELD: str
    def view_init(self, fields_list) -> None: ...
    def _field_create(self): ...
    def _add_field(self, name, field) -> None: ...
    def _pop_field(self, name): ...
    def _add_magic_fields(self) -> None: ...
    def compute_concurrency_field(self) -> None: ...
    def compute_concurrency_field_with_access(self) -> None: ...
    @classmethod
    def _build_model(cls, pool, cr): ...
    @classmethod
    def _build_model_check_base(model_class, cls) -> None: ...
    @classmethod
    def _build_model_check_parent(model_class, cls, parent_class) -> None: ...
    @classmethod
    def _build_model_attributes(cls, pool) -> None: ...
    def _add_manual_fields(self, partial) -> None: ...
    @classmethod
    def _init_constraints_onchanges(cls) -> None: ...
    @property
    def _constraint_methods(self): ...
    @property
    def _onchange_methods(self): ...
    def __new__(cls) -> None: ...
    def __init__(self, pool, cr) -> None: ...
    def _is_an_ordinary_table(self): ...
    def __export_xml_id(self): ...
    def _export_rows(self, fields): ...
    __export_rows: Any
    def export_data(self, fields_to_export, raw_data: bool = ...): ...
    def load(self, fields, data): ...
    def _add_fake_fields(self, fields): ...
    def _extract_records(self, fields_, data, log=...): ...
    def _convert_records(self, records, log=...) -> None: ...
    def _validate_fields(self, field_names) -> None: ...
    def default_get(self, fields_list): ...
    def fields_get_keys(self): ...
    def _rec_name_fallback(self): ...
    def view_header_get(self, view_id: Any | None = ..., view_type: str = ...): ...
    def user_has_groups(self, groups): ...
    def _get_default_form_view(self): ...
    def _get_default_search_view(self): ...
    def _get_default_tree_view(self): ...
    def _get_default_pivot_view(self): ...
    def _get_default_kanban_view(self): ...
    def _get_default_graph_view(self): ...
    def _get_default_calendar_view(self): ...
    def load_views(self, views, options: Any | None = ...): ...
    def fields_view_get(
        self,
        view_id: Any | None = ...,
        view_type: str = ...,
        toolbar: bool = ...,
        submenu: bool = ...,
    ): ...
    def get_formview_id(self): ...
    def get_formview_action(self): ...
    def get_access_action(self): ...
    def search_count(self, args) -> int: ...
    def search(
        self: _ModelT,
        args,
        offset: int = ...,
        limit: Any | None = ...,
        order: Any | None = ...,
        count: bool = ...,
    ) -> _ModelT: ...
    def _compute_display_name(self) -> None: ...
    def name_get(self): ...
    def name_create(self, name): ...
    def name_search(
        self,
        name: str = ...,
        args: Any | None = ...,
        operator: str = ...,
        limit: int = ...,
    ): ...
    def _name_search(
        self,
        name: str = ...,
        args: Any | None = ...,
        operator: str = ...,
        limit: int = ...,
        name_get_uid: Any | None = ...,
    ): ...
    def _add_missing_default_values(self, values): ...
    @classmethod
    def clear_caches(cls) -> None: ...
    def _read_group_fill_results(
        self,
        domain,
        groupby,
        remaining_groupbys,
        aggregated_fields,
        count_field,
        read_group_result,
        read_group_order: Any | None = ...,
    ): ...
    def _read_group_prepare(
        self, orderby, aggregated_fields, annotated_groupbys, query
    ): ...
    def _read_group_process_groupby(self, gb, query): ...
    def _read_group_prepare_data(self, key, value, groupby_dict): ...
    def _read_group_format_result(self, data, annotated_groupbys, groupby, domain): ...
    def read_group(
        self,
        domain,
        fields,
        groupby,
        offset: int = ...,
        limit: Any | None = ...,
        orderby: bool = ...,
        lazy: bool = ...,
    ): ...
    def _read_group_raw(
        self,
        domain,
        fields,
        groupby,
        offset: int = ...,
        limit: Any | None = ...,
        orderby: bool = ...,
        lazy: bool = ...,
    ): ...
    def _inherits_join_add(self, current_model, parent_model_name, query): ...
    def _inherits_join_calc(
        self, alias, fname, query, implicit: bool = ..., outer: bool = ...
    ): ...
    def _parent_store_compute(self): ...
    def _check_selection_field_value(self, field, value) -> None: ...
    def _check_removed_columns(self, log: bool = ...) -> None: ...
    def _save_constraint(self, constraint_name, type, definition, module) -> None: ...
    def _drop_constraint(self, source_table, constraint_name) -> None: ...
    def _save_relation_table(self, relation_table, module) -> None: ...
    def _m2o_add_foreign_key_checked(
        self, source_field, dest_model, ondelete
    ) -> None: ...
    def _m2o_add_foreign_key_unchecked(
        self, source_table, source_field, dest_model, ondelete, module
    ) -> None: ...
    def _m2o_fix_foreign_key(
        self, source_table, source_field, dest_model, ondelete
    ) -> None: ...
    def _init_column(self, column_name) -> None: ...
    def _auto_init(self) -> None: ...
    def _auto_end(self) -> None: ...
    def init(self) -> None: ...
    def _table_exist(self): ...
    def _create_table(self) -> None: ...
    def _parent_columns_exist(self): ...
    def _create_parent_columns(self) -> None: ...
    def _select_column_data(self): ...
    def _add_sql_constraints(self): ...
    def _execute_sql(self) -> None: ...
    def _add_inherited_fields(self) -> None: ...
    def _inherits_check(self) -> None: ...
    def _prepare_setup(self) -> None: ...
    def _setup_base(self, partial) -> None: ...
    def _setup_fields(self, partial) -> None: ...
    def _setup_complete(self) -> None: ...
    def fields_get(self, allfields: Any | None = ..., attributes: Any | None = ...): ...
    def get_empty_list_help(self, help): ...
    def check_field_access_rights(self, operation, fields): ...
    def read(self, fields: Any | None = ..., load: str = ...): ...
    def _prefetch_field(self, field) -> None: ...
    def _read_from_database(self, field_names, inherited_field_names=...): ...
    def get_metadata(self): ...
    def _check_concurrency(self) -> None: ...
    def _check_record_rules_result_count(self, result_ids, operation) -> None: ...
    def check_access_rights(self, operation, raise_exception: bool = ...): ...
    def check_access_rule(self, operation) -> None: ...
    def create_workflow(self): ...
    def delete_workflow(self): ...
    def step_workflow(self): ...
    def signal_workflow(self, signal): ...
    def redirect_workflow(self, old_new_ids): ...
    def unlink(self): ...
    def write(self, vals): ...
    def _write(self, vals): ...
    def create(self: _ModelT, vals) -> _ModelT: ...
    def _create(self, vals): ...
    def _where_calc(self, domain, active_test: bool = ...): ...
    def _check_qorder(self, word): ...
    def _apply_ir_rules(self, query, mode: str = ...) -> None: ...
    def _generate_translated_field(self, table_alias, field, query): ...
    def _generate_m2o_order_by(
        self, alias, order_field, query, reverse_direction, seen
    ): ...
    def _generate_order_by_inner(
        self,
        alias,
        order_spec,
        query,
        reverse_direction: bool = ...,
        seen: Any | None = ...,
    ): ...
    def _generate_order_by(self, order_spec, query): ...
    def _search(
        self,
        args,
        offset: int = ...,
        limit: Any | None = ...,
        order: Any | None = ...,
        count: bool = ...,
        access_rights_uid: Any | None = ...,
    ): ...
    def copy_data(self, default: Any | None = ...): ...
    def copy_translations(old, new): ...
    def copy(self: _ModelT, default: Any | None = ...) -> _ModelT: ...
    def exists(self: _ModelT) -> _ModelT: ...
    def _check_recursion(self, parent: Any | None = ...): ...
    def _check_m2m_recursion(self, field_name): ...
    def _get_external_ids(self): ...
    def get_external_id(self): ...
    get_xml_id: Any
    _get_xml_ids: Any
    def print_report(self, name, data): ...
    @classmethod
    def is_transient(cls): ...
    def _transient_clean_rows_older_than(self, seconds) -> None: ...
    def _transient_clean_old_rows(self, max_count) -> None: ...
    def _transient_vacuum(self, force: bool = ...): ...
    def resolve_2many_commands(
        self, field_name, commands, fields: Any | None = ...
    ): ...
    resolve_o2m_commands_to_record_dicts: Any
    def search_read(
        self,
        domain: Any | None = ...,
        fields: Any | None = ...,
        offset: int = ...,
        limit: Any | None = ...,
        order: Any | None = ...,
    ): ...
    def toggle_active(self) -> None: ...
    def _register_hook(self) -> None: ...
    @classmethod
    def _patch_method(cls, name, method) -> None: ...
    @classmethod
    def _revert_method(cls, name) -> None: ...
    @classmethod
    def _browse(cls, ids, env, prefetch: Any | None = ...): ...
    def browse(
        self: _ModelT, arg: Any | None = ..., prefetch: Any | None = ...
    ) -> _ModelT: ...
    @property
    def ids(self) -> List[str]: ...
    _cr: Cursor
    _uid: int
    _context: dict
    def ensure_one(self: _ModelT) -> _ModelT: ...
    def with_env(self: _ModelT, env) -> _ModelT: ...
    def sudo(self: _ModelT, user=...) -> _ModelT: ...
    def with_context(self: _ModelT, *args, **kwargs) -> _ModelT: ...
    def with_prefetch(self: _ModelT, prefetch: Any | None = ...) -> _ModelT: ...
    def _convert_to_cache(self, values, update: bool = ..., validate: bool = ...): ...
    def _convert_to_record(self, values): ...
    def _convert_to_write(self, values): ...
    def _mapped_func(self, func): ...
    def mapped(self, func): ...
    def _mapped_cache(self, name_seq): ...
    def filtered(self: _ModelT, func) -> _ModelT: ...
    def sorted(
        self: _ModelT, key: Any | None = ..., reverse: bool = ...
    ) -> _ModelT: ...
    def update(self, values) -> None: ...
    def new(self: _ModelT, values=...) -> _ModelT: ...
    def _is_dirty(self): ...
    def _get_dirty(self): ...
    def _set_dirty(self, field_name) -> None: ...
    def __nonzero__(self): ...
    def __len__(self) -> int: ...
    def __iter__(self: _ModelT) -> Generator[_ModelT]: ...
    def __contains__(self, item) -> bool: ...
    def __add__(self: _ModelT, other) -> _ModelT: ...
    def concat(self: _ModelT, *args) -> _ModelT: ...
    def __sub__(self: _ModelT, other) -> _ModelT: ...
    def __and__(self: _ModelT, other) -> _ModelT: ...
    def __or__(self: _ModelT, other) -> _ModelT: ...
    def union(self: _ModelT, *args) -> _ModelT: ...
    def __eq__(self, other) -> bool: ...
    def __ne__(self, other) -> bool: ...
    def __lt__(self, other) -> bool: ...
    def __le__(self, other) -> bool: ...
    def __gt__(self, other) -> bool: ...
    def __ge__(self, other) -> bool: ...
    def __int__(self): ...
    def __str__(self): ...
    def __unicode__(self): ...
    __repr__: Any
    def __hash__(self) -> int: ...
    def __getitem__(self, key): ...
    def __setitem__(self, key, value): ...
    def _cache(self): ...
    def _in_cache_without(self, field, limit=...): ...
    def refresh(self) -> None: ...
    def invalidate_cache(self, fnames: Any | None = ..., ids: Any | None = ...): ...
    def modified(self, fnames) -> None: ...
    def _recompute_check(self, field): ...
    def _recompute_todo(self, field) -> None: ...
    def _recompute_done(self, field) -> None: ...
    def recompute(self) -> None: ...
    def _has_onchange(self, field, other_fields): ...
    def _onchange_spec(self, view_info: Any | None = ...): ...
    _record: Any
    def _onchange_eval(self, field_name, onchange, result): ...
    def onchange(self, values, field_name, field_onchange): ...

class RecordCache(MutableMapping):
    _recs: Any
    def __init__(self, records) -> None: ...
    def contains(self, field): ...
    def __contains__(self, field): ...
    def get(self, field, default: Any | None = ...): ...
    def __getitem__(self, field): ...
    def __setitem__(self, field, value) -> None: ...
    def update(self, *args, **kwargs): ...
    def __delitem__(self, field) -> None: ...
    def __iter__(self): ...
    def __len__(self): ...

AbstractModel = BaseModel

class Model(AbstractModel):
    _auto: bool
    _register: bool
    _abstract: bool
    _transient: bool

class TransientModel(Model):
    _auto: bool
    _register: bool
    _abstract: bool
    _transient: bool

def itemgetter_tuple(items): ...
def convert_pgerror_23502(model, fields, info, e): ...
def convert_pgerror_23505(model, fields, info, e): ...

PGERROR_TO_OE: Any

def _normalize_ids(arg, atoms=...): ...