Administration Interface

class AdminSite:
    """
    Administrative interface site manager.
    
    Central registry for models and admin configuration with authentication.
    """
    name: str = 'admin'
    app_name: str = 'admin'
    
    def __init__(self, name: str = 'admin'): ...
    
    def register(self, model_or_iterable, admin_class=None, **options) -> None: ...
    def unregister(self, model_or_iterable) -> None: ...
    def is_registered(self, model) -> bool: ...
    def add_action(self, action, name: str = None) -> None: ...
    def disable_action(self, name: str) -> None: ...
    def get_action(self, name: str): ...
    def has_permission(self, request: HttpRequest) -> bool: ...
    def admin_view(self, view, cacheable: bool = False): ...
    def get_urls(self) -> list: ...
    def get_app_list(self, request: HttpRequest) -> list: ...
    def index(self, request: HttpRequest, extra_context: dict = None) -> HttpResponse: ...
    def app_index(self, request: HttpRequest, app_label: str, extra_context: dict = None) -> HttpResponse: ...
    def i18n_javascript(self, request: HttpRequest) -> HttpResponse: ...
    def logout(self, request: HttpRequest, extra_context: dict = None) -> HttpResponse: ...
    def login(self, request: HttpRequest, extra_context: dict = None) -> HttpResponse: ...
    def password_change(self, request: HttpRequest, extra_context: dict = None) -> HttpResponse: ...
    def password_change_done(self, request: HttpRequest, extra_context: dict = None) -> HttpResponse: ...
    def each_context(self, request: HttpRequest) -> dict: ...
    
    site_header: str
    site_title: str
    site_url: str
    index_title: str
    index_template: str
    app_index_template: str
    login_template: str
    login_form: str
    logout_template: str
    password_change_template: str
    password_change_done_template: str

site: AdminSite  # Default admin site instance

def autodiscover() -> None:
    """
    Automatically discover admin.py modules in installed apps.
    
    Imports admin modules to trigger model registration.
    """

class BaseModelAdmin:
    """
    Base functionality for model admin classes.
    
    Provides common admin features without ModelAdmin inheritance.
    """
    autocomplete_fields: tuple = ()
    raw_id_fields: tuple = ()
    fields = None
    exclude = None
    fieldsets = None
    filter_horizontal: tuple = ()
    filter_vertical: tuple = ()
    radio_fields: dict = {}
    prepopulated_fields: dict = {}
    formfield_overrides: dict = {}
    readonly_fields: tuple = ()
    ordering = None
    sortable_by = None
    view_on_site: bool = True
    show_full_result_count: bool = True
    
    def check(self, **kwargs) -> list: ...
    def formfield_for_dbfield(self, db_field, request: HttpRequest, **kwargs): ...
    def formfield_for_choice_field(self, db_field, request: HttpRequest, **kwargs): ...
    def formfield_for_foreignkey(self, db_field, request: HttpRequest, **kwargs): ...
    def formfield_for_manytomany(self, db_field, request: HttpRequest, **kwargs): ...
    def get_field_queryset(self, db, db_field, request: HttpRequest): ...
    def get_changelist(self, request: HttpRequest): ...
    def get_changelist_form(self, request: HttpRequest, **kwargs): ...
    def get_changelist_formset(self, request: HttpRequest, **kwargs): ...
    def lookup_allowed(self, lookup: str, value: str) -> bool: ...
    def to_field_allowed(self, request: HttpRequest, to_field: str) -> bool: ...
    def get_readonly_fields(self, request: HttpRequest, obj=None) -> tuple: ...
    def get_prepopulated_fields(self, request: HttpRequest, obj=None) -> dict: ...
    def get_queryset(self, request: HttpRequest): ...
    def message_user(self, request: HttpRequest, message: str, level: int = None, extra_tags: str = '', fail_silently: bool = False) -> None: ...
    def get_paginator(self, request: HttpRequest, queryset, per_page: int, orphans: int = 0, allow_empty_first_page: bool = True): ...
    def get_object(self, request: HttpRequest, object_id: str, from_field=None): ...
    def get_form(self, request: HttpRequest, obj=None, change: bool = False, **kwargs): ...
    def get_formsets_with_inlines(self, request: HttpRequest, obj=None): ...
    def get_formsets(self, request: HttpRequest, obj=None): ...
    def get_inline_instances(self, request: HttpRequest, obj=None) -> list: ...

class ModelAdmin(BaseModelAdmin):
    """
    Model administration interface configuration.
    
    Main class for customizing model admin behavior and display.
    """
    list_display: tuple = ('__str__',)
    list_display_links = None
    list_filter: tuple = ()
    list_select_related: bool = False
    list_per_page: int = 100
    list_max_show_all: int = 200
    list_editable: tuple = ()
    search_fields: tuple = ()
    search_help_text: str = None
    date_hierarchy: str = None
    save_as: bool = False
    save_as_continue: bool = True
    save_on_top: bool = False
    paginator = None
    preserve_filters: bool = True
    inlines: list = []
    add_form_template: str = None
    change_form_template: str = None
    change_list_template: str = None
    delete_confirmation_template: str = None
    delete_selected_confirmation_template: str = None
    object_history_template: str = None
    popup_response_template: str = None
    
    def get_urls(self) -> list: ...
    def get_model_perms(self, request: HttpRequest) -> dict: ...
    def has_view_permission(self, request: HttpRequest, obj=None) -> bool: ...
    def has_add_permission(self, request: HttpRequest) -> bool: ...
    def has_change_permission(self, request: HttpRequest, obj=None) -> bool: ...
    def has_delete_permission(self, request: HttpRequest, obj=None) -> bool: ...
    def has_module_permission(self, request: HttpRequest) -> bool: ...
    def get_queryset(self, request: HttpRequest): ...
    def get_search_results(self, request: HttpRequest, queryset, search_term: str) -> tuple: ...
    def get_preserved_filters(self, request: HttpRequest) -> str: ...
    def construct_change_message(self, request: HttpRequest, form, formsets: list, add: bool = False) -> list: ...
    def message_user(self, request: HttpRequest, message: str, level: int = None, extra_tags: str = '', fail_silently: bool = False) -> None: ...
    def save_model(self, request: HttpRequest, obj, form, change: bool) -> None: ...
    def delete_model(self, request: HttpRequest, obj) -> None: ...
    def save_related(self, request: HttpRequest, form, formsets: list, change: bool) -> None: ...
    def save_formset(self, request: HttpRequest, form, formset, change: bool) -> None: ...
    def get_ordering(self, request: HttpRequest) -> list: ...
    def get_search_fields(self, request: HttpRequest) -> tuple: ...
    def get_sortable_by(self, request: HttpRequest) -> tuple: ...
    def get_inline_instances(self, request: HttpRequest, obj=None) -> list: ...
    def get_inlines(self, request: HttpRequest, obj) -> list: ...
    def add_view(self, request: HttpRequest, form_url: str = '', extra_context: dict = None) -> HttpResponse: ...
    def change_view(self, request: HttpRequest, object_id: str, form_url: str = '', extra_context: dict = None) -> HttpResponse: ...
    def changelist_view(self, request: HttpRequest, extra_context: dict = None) -> HttpResponse: ...
    def delete_view(self, request: HttpRequest, object_id: str, extra_context: dict = None) -> HttpResponse: ...
    def history_view(self, request: HttpRequest, object_id: str, extra_context: dict = None) -> HttpResponse: ...
    def response_add(self, request: HttpRequest, obj, post_url_continue: str = None) -> HttpResponse: ...
    def response_change(self, request: HttpRequest, obj) -> HttpResponse: ...
    def response_delete(self, request: HttpRequest, obj_display: str, obj_id: str) -> HttpResponse: ...
    def get_changeform_initial_data(self, request: HttpRequest) -> dict: ...
    def get_deleted_objects(self, objs: list, request: HttpRequest) -> tuple: ...

class InlineModelAdmin(BaseModelAdmin):
    """
    Base class for inline model administration.
    
    Provides functionality for editing related objects within parent forms.
    """
    model = None
    fk_name: str = None
    formset = None
    form = None
    extra: int = 3
    min_num: int = None
    max_num: int = None
    template: str = None
    verbose_name: str = None
    verbose_name_plural: str = None
    can_delete: bool = True
    show_change_link: bool = False
    classes: list = None
    
    def get_formset(self, request: HttpRequest, obj=None, **kwargs): ...
    def get_queryset(self, request: HttpRequest): ...
    def get_extra(self, request: HttpRequest, obj=None, **kwargs) -> int: ...
    def get_min_num(self, request: HttpRequest, obj=None, **kwargs) -> int: ...
    def get_max_num(self, request: HttpRequest, obj=None, **kwargs) -> int: ...
    def has_add_permission(self, request: HttpRequest, obj=None) -> bool: ...
    def has_change_permission(self, request: HttpRequest, obj=None) -> bool: ...
    def has_delete_permission(self, request: HttpRequest, obj=None) -> bool: ...
    def has_view_permission(self, request: HttpRequest, obj=None) -> bool: ...

class StackedInline(InlineModelAdmin):
    """
    Inline admin with stacked layout.
    
    Displays each related object in a separate fieldset block.
    """
    template: str = 'admin/edit_inline/stacked.html'

class TabularInline(InlineModelAdmin):
    """
    Inline admin with tabular layout.
    
    Displays related objects in a compact table format.
    """
    template: str = 'admin/edit_inline/tabular.html'

class GenericInlineModelAdmin(InlineModelAdmin):
    """
    Inline admin for generic foreign key relationships.
    """
    ct_field: str = 'content_type'
    ct_fk_field: str = 'object_id'
    formset = None
    
    def get_formset(self, request: HttpRequest, obj=None, **kwargs): ...

class GenericStackedInline(GenericInlineModelAdmin):
    """
    Generic inline with stacked layout.
    """
    template: str = 'admin/edit_inline/stacked.html'

class GenericTabularInline(GenericInlineModelAdmin):
    """
    Generic inline with tabular layout.
    """
    template: str = 'admin/edit_inline/tabular.html'

def action(function=None, *, permissions: list = None, description: str = None):
    """
    Decorator for creating admin actions.
    
    Args:
        function: Action function to decorate
        permissions: Required permissions for action
        description: Human-readable action description
        
    Returns:
        Decorated action function
    """

def delete_selected(modeladmin, request: HttpRequest, queryset) -> HttpResponse:
    """
    Built-in action for deleting selected objects.
    
    Args:
        modeladmin: ModelAdmin instance
        request: HTTP request object
        queryset: Selected objects queryset
        
    Returns:
        Confirmation page or redirect after deletion
    """
delete_selected.short_description = "Delete selected %(verbose_name_plural)s"

def display(function=None, *, boolean: bool = None, ordering: str = None, description: str = None, empty_value: str = None):
    """
    Decorator for configuring admin field display.
    
    Args:
        function: Method to decorate
        boolean: Whether field represents boolean value
        ordering: Database field for sorting
        description: Column header text
        empty_value: Display value for empty fields
        
    Returns:
        Decorated display method
    """

def register(*models, site: AdminSite = None):
    """
    Decorator for registering models with admin site.
    
    Args:
        *models: Model classes to register
        site: Admin site instance (defaults to default site)
        
    Returns:
        Decorator function or admin class
    """

class AdminForm:
    """
    Wrapper for forms used in admin interface.
    
    Provides fieldset organization and admin-specific rendering.
    """
    def __init__(self, form, fieldsets: list, prepopulated_fields: dict, readonly_fields: list = None, model_admin=None): ...
    
    def __iter__(self): ...
    def __getitem__(self, name: str): ...
    def errors(self): ...
    def non_field_errors(self): ...
    def media(self): ...
    
    form: Form
    fieldsets: list
    prepopulated_fields: dict
    model_admin: ModelAdmin

class AdminErrorList(list):
    """
    Error list with admin-specific formatting.
    """
    def __init__(self, form, errors: list): ...
    def as_ul(self) -> str: ...
    def as_text(self) -> str: ...

class AdminReadonlyField:
    """
    Display-only field for admin forms.
    """
    def __init__(self, form, field: str, is_first: bool, model_admin=None): ...
    def label_tag(self) -> str: ...
    def contents(self) -> str: ...

class Fieldset:
    """
    Fieldset grouping for admin forms.
    """
    def __init__(self, form, name: str = None, readonly_fields: tuple = (), fields: tuple = (), classes: tuple = (), description: str = None, model_admin=None): ...
    
    def __iter__(self): ...
    def media(self): ...
    
    name: str
    fields: tuple
    classes: str
    description: str

class AdminDateWidget(DateInput):
    """
    Date input widget with admin calendar popup.
    """
    template_name: str = 'admin/widgets/date.html'

class AdminTimeWidget(TimeInput):
    """
    Time input widget with admin time picker.
    """
    template_name: str = 'admin/widgets/time.html'

class AdminSplitDateTime(SplitDateTimeWidget):
    """
    Split date/time widget for admin interface.
    """
    template_name: str = 'admin/widgets/split_datetime.html'

class AdminRadioSelect(RadioSelect):
    """
    Radio button widget for admin forms.
    """
    template_name: str = 'admin/widgets/radio.html'

class AdminFileWidget(ClearableFileInput):
    """
    File upload widget with admin styling.
    """
    template_name: str = 'admin/widgets/clearable_file_input.html'

class ForeignKeyRawIdWidget(TextInput):
    """
    Raw ID widget for foreign key fields.
    
    Displays foreign key as text input with lookup popup.
    """
    template_name: str = 'admin/widgets/foreign_key_raw_id.html'
    
    def __init__(self, rel, admin_site: AdminSite, attrs: dict = None, using: str = None): ...
    
    def url_parameters(self) -> dict: ...
    def label_and_url_for_value(self, value) -> tuple: ...

class ManyToManyRawIdWidget(ForeignKeyRawIdWidget):
    """
    Raw ID widget for many-to-many fields.
    
    Displays many-to-many as text input with lookup popup.
    """
    template_name: str = 'admin/widgets/many_to_many_raw_id.html'

class RelatedFieldWidgetWrapper(Widget):
    """
    Wrapper widget that adds related field links.
    
    Adds change/add/delete links for foreign key widgets.
    """
    template_name: str = 'admin/widgets/related_widget_wrapper.html'
    
    def __init__(self, widget: Widget, rel, admin_site: AdminSite, can_add_related: bool = None, 
                 can_change_related: bool = None, can_delete_related: bool = None, can_view_related: bool = None): ...

class AutocompleteSelect(Select):
    """
    Select widget with autocomplete functionality.
    """
    template_name: str = 'admin/widgets/autocomplete_select.html'
    
    def __init__(self, rel, admin_site: AdminSite, attrs: dict = None, choices: tuple = (), using: str = None): ...

class AutocompleteSelectMultiple(SelectMultiple):
    """
    Multiple select widget with autocomplete functionality.
    """
    template_name: str = 'admin/widgets/autocomplete_select.html'
    
    def __init__(self, rel, admin_site: AdminSite, attrs: dict = None, choices: tuple = (), using: str = None): ...

class SimpleListFilter:
    """
    Base class for simple list filters.
    
    Provides dropdown filtering in admin change list sidebar.
    """
    title: str = None
    parameter_name: str = None
    template: str = 'admin/filter.html'
    
    def __init__(self, request: HttpRequest, params: dict, model, model_admin): ...
    def has_output(self) -> bool: ...
    def choices(self, changelist): ...
    def queryset(self, request: HttpRequest, queryset): ...
    def expected_parameters(self) -> list: ...
    def used_parameters(self) -> dict: ...
    def lookups(self, request: HttpRequest, model_admin): ...

class BooleanFieldListFilter(SimpleListFilter):
    """
    Filter for boolean fields with Yes/No/All options.
    """

class ChoicesFieldListFilter(SimpleListFilter):
    """
    Filter for fields with choices using choice values.
    """

class DateFieldListFilter(SimpleListFilter):
    """
    Filter for date fields with preset time ranges.
    """

class AllValuesFieldListFilter(SimpleListFilter):
    """
    Filter showing all distinct values for a field.
    """

class RelatedFieldListFilter(SimpleListFilter):
    """
    Filter for foreign key relationships.
    """

class RelatedOnlyFieldListFilter(RelatedFieldListFilter):
    """
    Filter for foreign keys showing only related objects.
    """

class EmptyFieldListFilter(SimpleListFilter):
    """
    Filter for empty/non-empty field values.
    """

def display_for_field(value, field, empty_value_display: str) -> str:
    """
    Format field value for admin display.
    
    Args:
        value: Field value to format
        field: Model field instance
        empty_value_display: Text for empty values
        
    Returns:
        Formatted display string
    """

def display_for_value(value, empty_value_display: str, boolean: bool = False) -> str:
    """
    Format raw value for admin display.
    
    Args:
        value: Value to format
        empty_value_display: Text for empty values
        boolean: Whether to format as boolean
        
    Returns:
        Formatted display string
    """

def label_for_field(name: str, model, model_admin=None, return_attr: bool = False) -> str:
    """
    Get display label for model field or attribute.
    
    Args:
        name: Field or attribute name
        model: Model class
        model_admin: ModelAdmin instance
        return_attr: Whether to return attribute info
        
    Returns:
        Field label string
    """

def help_text_for_field(name: str, model) -> str:
    """
    Get help text for model field.
    
    Args:
        name: Field name
        model: Model class
        
    Returns:
        Field help text
    """

def flatten_fieldsets(fieldsets: list) -> list:
    """
    Extract field names from nested fieldset structure.
    
    Args:
        fieldsets: Nested fieldset configuration
        
    Returns:
        Flat list of field names
    """

def normalize_fieldsets(fieldsets: list) -> list:
    """
    Normalize fieldset configuration format.
    
    Args:
        fieldsets: Raw fieldset configuration
        
    Returns:
        Normalized fieldset structure
    """

def construct_change_message(form, formsets: list, add: bool) -> list:
    """
    Build change message for admin log entries.
    
    Args:
        form: Main model form
        formsets: List of related formsets
        add: Whether this is object creation
        
    Returns:
        List of change descriptions
    """

HORIZONTAL: int = 1  # Horizontal filter widget layout
VERTICAL: int = 2    # Vertical filter widget layout

# Field display options
class FieldListFilter:
    """Base class for admin list filters."""

class ListFilter:
    """Base interface for admin list filtering."""

class AdminCaption:
    """Caption display configuration for admin."""

# Admin template contexts
ADMIN_TEMPLATES: dict = {
    'admin/base.html': 'Base admin template',
    'admin/change_form.html': 'Object change form template',
    'admin/change_list.html': 'Object list template',
    'admin/delete_confirmation.html': 'Delete confirmation template',
    'admin/object_history.html': 'Object history template',
    'admin/popup_response.html': 'Popup response template',
}