odoo-stubs/odoo-stubs/fields.pyi

import datetime
import enum
from typing import Any, Callable, Container, Collection, Iterator, Sequence, TypeVar, Union

import psycopg2
from markupsafe import Markup

from .api import Environment, Registry
from .models import BaseModel
from .tools import date_utils, float_utils

_ModelT = TypeVar('_ModelT', bound=BaseModel)
_Selection = list[tuple[str, str]]
_SelectionRaw = _Selection | Callable[..., _Selection] | str
_Domain = list
_DomainRaw = _Domain | Callable[..., _Domain]
_CommandList = list[tuple[BaseModel, list]]
_SeqIntT = TypeVar('_SeqIntT', bound=Sequence[int])

DATE_LENGTH: int
DATETIME_LENGTH: int
NO_ACCESS: str
IR_MODELS: tuple[str, ...]
NoneType: type[None]
Default: object

def first(records: _ModelT) -> _ModelT: ...
def resolve_mro(model: BaseModel, name: str, predicate: Callable[..., bool]): ...

class MetaField(type):
    by_type: dict
    def __init__(cls: type[Field], name, bases, attrs) -> None: ...

class Field(metaclass=MetaField):
    type: str | None
    relational: bool
    translate: bool
    column_type: tuple[str, str] | None
    write_sequence: int
    args: dict[str, Any] | None
    _module: str
    _modules: tuple[str, ...]
    _setup_done: bool
    _sequence: int | None
    _base_fields: tuple[Field, ...]
    _extra_keys: tuple[str, ...]
    _direct: bool
    _toplevel: bool
    automatic: bool
    inherited: bool
    inherited_field: Field | None
    name: str
    model_name: str
    comodel_name: str | None
    store: bool
    index: str | bool | None
    manual: bool
    copy: bool
    _depends: Collection[str, ...] | None
    _depends_context: Collection[str, ...] | None
    recursive: bool
    compute: str | Callable | None
    compute_sudo: bool
    precompute: bool
    inverse: str | Callable | None
    search: str | Callable | None
    related: str | None
    company_dependent: bool
    default: Any
    string: str | None
    help: str | None
    invisible: bool
    readonly: bool
    required: bool
    states: dict[str, list[tuple]] | None
    groups: str | None
    change_default: bool
    related_field: Field | None
    group_operator: str | None
    group_expand: str | None
    prefetch: bool
    default_export_compatible: bool
    related_attrs: list[tuple[str, str]]
    description_attrs: list[tuple[str, str]]
    def __init__(self, string: str = ..., **kwargs) -> None: ...
    def new(self, **kwargs): ...
    def __str__(self) -> str: ...
    def __repr__(self) -> str: ...
    def __set_name__(self, owner: type[BaseModel], name: str) -> None: ...
    def _get_attrs(self, model_class: type[BaseModel], name: str) -> dict[str, Any]: ...
    def _setup_attrs(self, model_class: type[BaseModel], name: str): ...
    def prepare_setup(self) -> None: ...
    def setup(self, model: BaseModel) -> None: ...
    def setup_nonrelated(self, model: BaseModel) -> None: ...
    def get_depends(self, model: BaseModel) -> tuple: ...
    def setup_related(self, model: BaseModel) -> None: ...
    def traverse_related(self, record: _ModelT) -> tuple[_ModelT, Field]: ...
    def _compute_related(self, records: BaseModel) -> None: ...
    def _process_related(self, value): ...
    def _inverse_related(self, records: BaseModel) -> None: ...
    def _search_related(self, records: BaseModel, operator: str, value) -> list: ...
    _related_comodel_name: str | None
    _related_string: str | None
    _related_help: str | None
    _related_groups: str | None
    _related_group_operator: str | None
    @property
    def base_field(self) -> Field: ...
    @property
    def groupable(self) -> bool: ...
    def _default_company_dependent(self, model: BaseModel): ...
    def _compute_company_dependent(self, records: BaseModel) -> None: ...
    def _inverse_company_dependent(self, records: BaseModel) -> None: ...
    def _search_company_dependent(self, records: BaseModel, operator: str, value): ...
    def resolve_depends(self, registry: Registry) -> Iterator[tuple]: ...
    def get_description(self, env: Environment, attributes: Container[str] | None = ...) -> dict[str, Any]: ...
    _description_name: str
    _description_type: str
    _description_store: bool | None
    _description_manual: Any
    _description_related: str | None
    _description_company_dependent: bool
    _description_readonly: bool
    _description_required: bool
    _description_states: dict[str, list[tuple]] | None
    _description_groups: str | None
    _description_change_default: bool
    _description_group_operator: str | None
    _description_default_export_compatible: bool
    def _description_depends(self, env: Environment): ...
    @property
    def _description_searchable(self) -> bool: ...
    @property
    def _description_sortable(self) -> bool: ...
    def _description_string(self, env: Environment) -> str | None: ...
    def _description_help(self, env: Environment) -> str | None: ...
    def is_editable(self) -> bool: ...
    def null(self, record: BaseModel) -> bool: ...
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...): ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...): ...
    def convert_to_record(self, value, record: BaseModel): ...
    def convert_to_record_multi(self, values, records: BaseModel): ...
    def convert_to_read(self, value, record: BaseModel, use_name_get: bool = ...): ...
    def convert_to_write(self, value, record: BaseModel): ...
    def convert_to_onchange(self, value, record: BaseModel, names): ...
    def convert_to_export(self, value, record: BaseModel): ...
    def convert_to_display_name(self, value, record: BaseModel): ...
    @property
    def column_order(self) -> int: ...
    def update_db(self, model: BaseModel, columns: dict[str, Any]): ...
    def update_db_column(self, model: BaseModel, column: dict | None) -> None: ...
    def _convert_db_column(self, model: BaseModel, column: dict | None) -> None: ...
    def update_db_notnull(self, model: BaseModel, column: dict | None) -> None: ...
    def update_db_related(self, model: BaseModel) -> None: ...
    def read(self, records: BaseModel) -> None: ...
    def create(self, record_values: list[tuple[BaseModel, Any]]) -> None: ...
    def write(self, records: _ModelT, value) -> _ModelT: ...
    def __get__(self, record: Union[BaseModel, None], owner): ...
    def mapped(self, records: BaseModel): ...
    def __set__(self, records: BaseModel, value): ...
    def recompute(self, records: BaseModel) -> None: ...
    def compute_value(self, records: BaseModel) -> None: ...
    def determine_inverse(self, records: BaseModel) -> None: ...
    def determine_domain(self, records: BaseModel, operator: str, value) -> list: ...

class Boolean(Field):
    type: str
    column_type: type[str, str]
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...) -> bool: ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...) -> bool: ...
    def convert_to_export(self, value, record: BaseModel): ...

class Integer(Field):
    type: str
    column_type: type[str, str]
    group_operator: str
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...) -> int: ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...) -> int | None: ...
    def convert_to_record(self, value, record: BaseModel): ...
    def convert_to_read(self, value, record: BaseModel, use_name_get: bool = ...): ...
    def _update(self, records: BaseModel, value) -> None: ...
    def convert_to_export(self, value, record): ...

class Float(Field):
    type: str
    _digits: tuple[int, int] | str | None
    group_operator: str
    def __init__(self, string: str = ..., digits: tuple[int, int] | str | None =..., **kwargs) -> None: ...
    @property
    def column_type(self): ...
    def get_digits(self, env: Environment) -> tuple[int, int]: ...
    _related__digits: Any
    def _description_digits(self, env: Environment) -> type[int, int]: ...
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...) -> float: ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...) -> float: ...
    def convert_to_record(self, value, record: BaseModel): ...
    def convert_to_export(self, value, record: BaseModel): ...
    round = float_utils.float_round
    is_zero = float_utils.float_is_zero
    compare = float_utils.float_compare

class Monetary(Field):
    type: str
    write_sequence: int
    column_type: tuple[str, str]
    currency_field: str | None
    group_operator: str
    def __init__(self, string: str = ..., currency_field : str =..., **kwargs) -> None: ...
    def _description_currency_field(self, env: Environment) -> str: ...
    def get_currency_field(self, model: BaseModel) -> str: ...
    def setup_nonrelated(self, model: BaseModel) -> None: ...
    def setup_related(self, model: BaseModel) -> None: ...
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...) -> float: ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...) -> float: ...
    def convert_to_record(self, value, record: BaseModel): ...
    def convert_to_read(self, value, record: BaseModel, use_name_get: bool = ...): ...
    def convert_to_write(self, value, record: BaseModel): ...

class _String(Field):
    translate: Callable | bool
    unaccent: bool
    def __init__(self, string: str = ..., **kwargs) -> None: ...
    _related_translate: bool
    def _description_translate(self, env: Environment) -> bool: ...
    def _convert_db_column(self, model: BaseModel, column: dict) -> None: ...
    def get_trans_terms(self, value) -> list: ...
    def get_text_content(self, term): ...
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...): ...
    def _convert_from_cache_to_column(self, value): ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...): ...
    def convert_to_record(self, value, record: BaseModel): ...
    def convert_to_write(self, value, record: BaseModel): ...
    def get_trans_func(self, records: BaseModel) -> Callable: ...
    def get_translation_dictionary(self, from_lang_value: str, to_lang_values: dict) -> dict: ...
    def _get_stored_translations(self, record: BaseModel) -> dict[str, str]: ...
    def write(self, records: _ModelT, value) -> _ModelT: ...

class Char(_String):
    type: str
    size: int | None
    trim: bool
    def _setup_attrs(self, model_class: type[BaseModel], name: str) -> None: ...
    @property
    def column_type(self) -> tuple[str, str]: ...
    def update_db_column(self, model: BaseModel, column: dict | None) -> None: ...
    _related_size: int | None
    _related_trim: bool
    _description_size: int | None
    _description_trim: bool
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...) -> str | None: ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...) -> str | None: ...

class Text(_String):
    type: str
    @property
    def column_type(self) -> tuple[str, str]: ...
    def convert_to_cache(self, value, record, validate: bool = ...) -> str | None: ...

class Html(_String):
    type: str
    sanitize: bool
    sanitize_overridable: bool
    sanitize_tags: bool
    sanitize_attributes: bool
    sanitize_style: bool
    sanitize_form: bool
    strip_style: bool
    strip_classes: bool
    def _get_attrs(self, model_class: type[BaseModel], name: str) -> dict[str, Any]: ...
    @property
    def column_type(self) -> tuple[str, str]: ...
    _related_sanitize: bool
    _related_sanitize_tags: bool
    _related_sanitize_attributes: bool
    _related_sanitize_style: bool
    _related_strip_style: bool
    _related_strip_classes: bool
    _description_sanitize: bool
    _description_sanitize_tags: bool
    _description_sanitize_attributes: bool
    _description_sanitize_style: bool
    _description_strip_style: bool
    _description_strip_classes: bool
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...) -> Markup | None: ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...) -> Markup | None: ...
    def _convert(self, value, record: BaseModel, validate: bool) -> Markup | None: ...
    def convert_to_record(self, value, record: BaseModel) -> Markup | None: ...
    def convert_to_read(self, value, record: BaseModel, use_name_get: bool = ...) -> Markup | None: ...
    def get_trans_terms(self, value) -> list: ...

class Date(Field):
    type: str
    column_type: tuple[str, str]
    start_of = date_utils.start_of
    end_of = date_utils.end_of
    add = date_utils.add
    subtract = date_utils.subtract
    @staticmethod
    def today(*args) -> datetime.date: ...
    @staticmethod
    def context_today(record: BaseModel, timestamp: datetime.datetime | None = ...) -> datetime.date: ...
    @staticmethod
    def to_date(value) -> datetime.date | None: ...
    from_string = to_date
    @staticmethod
    def to_string(value: datetime.datetime | datetime.date) -> str: ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...) -> datetime.date | None: ...
    def convert_to_export(self, value, record: BaseModel): ...

class Datetime(Field):
    type: str
    column_type: tuple[str, str]
    start_of = date_utils.start_of
    end_of = date_utils.end_of
    add = date_utils.add
    subtract = date_utils.subtract
    @staticmethod
    def now(*args) -> datetime.datetime: ...
    @staticmethod
    def today(*args) -> datetime.datetime: ...
    @staticmethod
    def context_timestamp(record: BaseModel, timestamp: datetime.datetime) -> datetime.datetime: ...
    @staticmethod
    def to_datetime(value) -> datetime.datetime | None: ...
    from_string = to_datetime
    @staticmethod
    def to_string(value: datetime.datetime | datetime.date) -> str: ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...) -> datetime.datetime | None: ...
    def convert_to_export(self, value, record: BaseModel): ...
    def convert_to_display_name(self, value, record: BaseModel) -> str: ...

_BINARY = memoryview

class Binary(Field):
    type: str
    prefetch: bool
    _depends_context: tuple[str]
    attachment: bool
    @property
    def column_type(self) -> tuple[str, str] | None: ...
    def _get_attrs(self, model_class: type[BaseModel], name: str) -> dict[str, Any]: ...
    _description_attachment: bool
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...) -> psycopg2.Binary | None: ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...) -> bytes | None: ...
    def convert_to_record(self, value, record: BaseModel) -> bytes: ...
    def compute_value(self, records: BaseModel) -> None: ...
    def read(self, records: BaseModel) -> None: ...
    def create(self, record_values: list[tuple[BaseModel, Any]]) -> None: ...
    def write(self, records: _ModelT, value) -> _ModelT: ...

class Image(Binary):
    max_width: int
    max_height: int
    verify_resolution: bool
    def create(self, record_values: list[tuple[BaseModel, Any]]) -> None: ...
    def write(self, records: BaseModel, value) -> None: ...
    def _image_process(self, value): ...
    def _process_related(self, value): ...

class Selection(Field):
    type: str
    column_type: tuple[str, str]
    selection: _SelectionRaw
    validate: bool
    ondelete: dict[str, Any] | None
    def __init__(self, selection: _SelectionRaw = ..., string: str = ..., **kwargs) -> None: ...
    def setup_nonrelated(self, model: BaseModel) -> None: ...
    def setup_related(self, model: BaseModel): ...
    def _get_attrs(self, model_class: type[BaseModel], name: str) -> dict[str, Any]: ...
    def _setup_attrs(self, model_class: type[BaseModel], name: str) -> None: ...
    def _selection_modules(self, model: BaseModel) -> dict[str, set[str, str]]: ...
    def _description_selection(self, env: Environment) -> _Selection: ...
    def _default_group_expand(self, records: BaseModel, groups, domain, order) -> _Selection: ...
    def get_values(self, env: Environment) -> _Selection: ...
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...): ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...): ...
    def convert_to_export(self, value, record: BaseModel): ...

class Reference(Selection):
    type: str
    @property
    def column_type(self) -> tuple[str, str]: ...
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...) -> str | None: ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...) -> str | None: ...
    def convert_to_record(self, value, record: BaseModel) -> Union[BaseModel, None]: ...
    def convert_to_read(self, value, record: BaseModel, use_name_get: bool = ...) -> str | bool: ...
    def convert_to_export(self, value, record: BaseModel) -> str: ...
    def convert_to_display_name(self, value, record: BaseModel) -> str: ...

class _Relational(Field):
    relational: bool
    domain: _DomainRaw
    context: dict
    check_company: bool
    def __get__(self, records: Union[BaseModel, None], owner) -> BaseModel: ...
    comodel_name: str
    def setup_nonrelated(self, model: BaseModel) -> None: ...
    def get_domain_list(self, model: BaseModel) -> _Domain: ...
    @property
    def _related_domain(self) -> _DomainRaw: ...
    _related_context: dict
    _description_relation: str | None
    _description_context: dict
    def _description_domain(self, env: Environment) -> _Domain: ...
    def null(self, record: BaseModel) -> BaseModel: ...

class Many2one(_Relational):
    type: str
    column_type: tuple[str, str]
    ondelete: str | None
    auto_join: bool
    delegate: bool
    def __init__(self, comodel_name: str = ..., string: str = ..., **kwargs) -> None: ...
    def _setup_attrs(self, model_class: type[BaseModel], name: str) -> None: ...
    def setup_nonrelated(self, model: BaseModel) -> None: ...
    def update_db(self, model: BaseModel, columns): ...
    def update_db_column(self, model: BaseModel, column) -> None: ...
    def update_db_foreign_key(self, model: BaseModel, column) -> None: ...
    def _update(self, records: BaseModel, value) -> None: ...
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...): ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...): ...
    def convert_to_record(self, value, record: BaseModel): ...
    def convert_to_record_multi(self, values, records: BaseModel): ...
    def convert_to_read(self, value, record: BaseModel, use_name_get: bool = ...): ...
    def convert_to_write(self, value, record: BaseModel): ...
    def convert_to_export(self, value, record: BaseModel) -> str: ...
    def convert_to_display_name(self, value, record: BaseModel) -> str: ...
    def convert_to_onchange(self, value, record: BaseModel, names): ...
    def write(self, records: _ModelT, value) -> _ModelT: ...
    def _remove_inverses(self, records: BaseModel, value): ...
    def _update_inverses(self, records: BaseModel, value) -> None: ...

class Many2oneReference(Integer):
    type: str
    model_field: str | None
    _related_model_field: str | None
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...): ...
    def _remove_inverses(self, records: BaseModel, value) -> None: ...
    def _update_inverses(self, records: BaseModel, value) -> None: ...
    def _record_ids_per_res_model(self, records: BaseModel) -> dict[str, set]: ...

class Json(Field):
    type: str
    column_type: tuple[str, str]
    def convert_to_record(self, value, record: BaseModel): ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...): ...
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...): ...

class Properties(Field):
    type: str
    column_type: tuple[str, str]
    copy: bool
    prefetch: bool
    write_sequence: int
    store: bool
    readonly: bool
    precompute: bool
    definition: str | None
    definition_record: str | None
    definition_record_field: str | None
    _description_definition_record: str | None
    _description_definition_record_field: str | None
    ALLOWED_TYPES: tuple[str, ...]
    _depends: tuple[str, ...]
    compute: Callable
    def _setup_attrs(self, model_class: type[BaseModel], name: str) -> None: ...
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...): ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...): ...
    def convert_to_record(self, value, record: BaseModel): ...
    def convert_to_read(self, value, record: BaseModel, use_name_get: bool = ...): ...
    def convert_to_write(self, value, record: BaseModel): ...
    def convert_to_onchange(self, value, record: BaseModel, names): ...
    def read(self, records: BaseModel) -> None: ...
    def write(self, records: _ModelT, value) -> _ModelT: ...
    def _compute(self, records: BaseModel) -> None: ...
    def _add_default_values(self, env: Environment, values: dict[str, Any]): ...
    def _get_properties_definition(self, record: BaseModel): ...
    @classmethod
    def _add_display_name(cls, values_list: list[dict], env: Environment, value_keys: tuple[str] = ...) -> None: ...
    @classmethod
    def _remove_display_name(cls, values_list: list[dict], value_key: str = ...) -> None: ...
    @classmethod
    def _add_missing_names(cls, values_list: list[dict]) -> None: ...
    @classmethod
    def _parse_json_types(cls, values_list: list[dict], env: Environment) -> None: ...
    @classmethod
    def _list_to_dict(cls, values_list: list[dict]) -> dict: ...
    @classmethod
    def _dict_to_list(cls, values_dict: dict, properties_definition: Sequence[dict]) -> Sequence[dict]: ...

class PropertiesDefinition(Field):
    type: str
    column_type: tuple[str, str]
    copy: bool
    readonly: bool
    prefetch: bool
    REQUIRED_KEYS: tuple[str, ...]
    ALLOWED_KEYS: tuple[str, ...]
    def convert_to_column(self, value, record: BaseModel, values: Any | None = ..., validate: bool = ...): ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...): ...
    def convert_to_record(self, value, record: BaseModel): ...
    def convert_to_read(self, value, record: BaseModel, use_name_get: bool = ...): ...
    @classmethod
    def _validate_properties_definition(cls, properties_definition: Sequence[dict], env): ...

class Command(enum.IntEnum):
    CREATE: int
    UPDATE: int
    DELETE: int
    UNLINK: int
    LINK: int
    CLEAR: int
    SET: int
    @classmethod
    def create(cls, values: dict) -> tuple[int, int, dict]: ...
    @classmethod
    def update(cls, id: int, values: dict) -> tuple[int, int, dict]: ...
    @classmethod
    def delete(cls, id: int) -> tuple[int, int, int]: ...
    @classmethod
    def unlink(cls, id: int) -> tuple[int, int, int]: ...
    @classmethod
    def link(cls, id: int) -> tuple[int, int, int]: ...
    @classmethod
    def clear(cls) -> tuple[int, int, int]: ...
    @classmethod
    def set(cls, ids: _SeqIntT) -> tuple[int, int, _SeqIntT]: ...

class _RelationalMulti(_Relational):
    write_sequence: int
    def _update(self, records: BaseModel, value): ...
    def convert_to_cache(self, value, record: BaseModel, validate: bool = ...): ...
    def convert_to_record(self, value, record: BaseModel): ...
    def convert_to_record_multi(self, values, records: BaseModel): ...
    def convert_to_read(self, value, record: BaseModel, use_name_get: bool = ...): ...
    def convert_to_write(self, value, record: BaseModel): ...
    def convert_to_export(self, value, record: BaseModel) -> str: ...
    def convert_to_display_name(self, value, record: BaseModel) -> None: ...
    def get_depends(self, model: BaseModel): ...
    def create(self, record_values: list[tuple[BaseModel, Any]]) -> None: ...
    def write(self, records: BaseModel, value): ...
    def write_batch(self, records_commands_list: _CommandList, create: bool = ...): ...

class One2many(_RelationalMulti):
    type: str
    inverse_name: str | None
    auto_join: bool
    copy: bool
    def __init__(self, comodel_name: str = ..., inverse_name: str = ..., string: str = ..., **kwargs) -> None: ...
    def setup_nonrelated(self, model: BaseModel) -> None: ...
    _description_relation_field: str | None
    def update_db(self, model: BaseModel, columns) -> None: ...
    def get_domain_list(self, records: BaseModel): ...
    def __get__(self, records: BaseModel, owner) -> BaseModel: ...
    def read(self, records: BaseModel): ...
    def write_real(self, records_commands_list: _CommandList, create: bool = ...): ...
    def write_new(self, records_commands_list: _CommandList): ...

class Many2many(_RelationalMulti):
    type: str
    _explicit: bool
    relation: str | None
    column1: str | None
    column2: str | None
    auto_join: bool
    ondelete: str
    def __init__(self, comodel_name: str =..., relation: str = ..., column1: str = ..., column2: str = ..., string: str = ..., **kwargs) -> None: ...
    def setup_nonrelated(self, model: BaseModel) -> None: ...
    def update_db(self, model: BaseModel, columns) -> None: ...
    def update_db_foreign_keys(self, model: BaseModel) -> None: ...
    @property
    def groupable(self) -> bool: ...
    def read(self, records: BaseModel) -> None: ...
    def write_real(self, records_commands_list: _CommandList, create: bool = ...): ...
    def write_new(self, records_commands_list: _CommandList): ...

class Id(Field):
    type: str
    column_type: tuple[str, str]
    string: str
    store: bool
    readonly: bool
    prefetch: bool
    def update_db(self, model: BaseModel, columns) -> None: ...
    def __get__(self, record: BaseModel, owner): ...
    def __set__(self, record: BaseModel, value) -> None: ...

class PrefetchMany2one:
    __slots__ = 'record', 'field'
    record: BaseModel
    field: Field
    def __init__(self, record: BaseModel, field: Field) -> None: ...
    def __iter__(self) -> Iterator[int]: ...
    def __reversed__(self) -> Iterator[int]: ...

class PrefetchX2many:
    __slots__ = 'record', 'field'
    record: BaseModel
    field: Field
    def __init__(self, record: BaseModel, field: Field) -> None: ...
    def __iter__(self) -> Iterator[int]: ...
    def __reversed__(self) -> Iterator[int]: ...

def apply_required(model: BaseModel, field_name: str) -> None: ...