"""
Generated by scripts/generate_schema.py on 2026-02-15 19:09:35
DO NOT EDIT MANUALLY - use the generator script to update.
"""

from collections.abc import Iterator, MutableMapping
from dataclasses import asdict, dataclass, field, fields
from pathlib import Path
from typing import Any, Literal

TemplateBackendType = Literal[
    "django.template.backends.django.DjangoTemplates",
    "django.template.backends.jinja2.Jinja2",
]
TaskBackendType = Literal[
    "django.tasks.backends.immediate.ImmediateBackend",
    "django.tasks.backends.dummy.DummyBackend",
]
CacheBackendType = Literal[
    "django.core.cache.backends.db.DatabaseCache",
    "django.core.cache.backends.dummy.DummyCache",
    "django.core.cache.backends.filebased.FileBasedCache",
    "django.core.cache.backends.locmem.LocMemCache",
    "django.core.cache.backends.memcached.PyMemcacheCache",
    "django.core.cache.backends.memcached.PyLibMCCache",
    "django.core.cache.backends.redis.RedisCache",
]
DatabaseEngineType = Literal[
    "django.db.backends.postgresql",
    "django.db.backends.mysql",
    "django.db.backends.sqlite3",
    "django.db.backends.oracle",
]
AuthPasswordValidatorNameType = Literal[
    "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
    "django.contrib.auth.password_validation.MinimumLengthValidator",
    "django.contrib.auth.password_validation.CommonPasswordValidator",
    "django.contrib.auth.password_validation.NumericPasswordValidator",
]


@dataclass
class BaseSchema(MutableMapping):
    """
    Base schema class for all settings.

    Implements the MutableMapping interface so that schemas can be used for DJango dictionary
    settings.
    """

    def to_dict(self) -> dict[str, Any]:
        # Exclude None values
        return {k: v for k, v in asdict(self).items() if v is not None}

    def __getitem__(self, key: str) -> Any:
        # Allow dict-like access: settings.DATABASES['default']['ENGINE']
        if not hasattr(self, key):
            raise KeyError(key)

        return getattr(self, key)

    def __setitem__(self, key: str, value: Any) -> None:
        setattr(self, key, value)

    def __delitem__(self, key: str) -> None:
        # Check if attribute exists first
        if not hasattr(self, key):
            raise KeyError(key)

        # Check if it is a dataclass field
        is_field = any(f.name == key for f in fields(self))
        if is_field:
            setattr(self, key, None)
        else:
            try:
                delattr(self, key)
            except AttributeError:
                raise KeyError(key) from None

    def __iter__(self) -> Iterator[str]:
        seen = set()

        for f in fields(self):
            seen.add(f.name)

            # Include None values to behave like a proper dictionary where keys exist
            yield f.name

        # Handle ad-hoc attributes in __dict__
        for k in self.__dict__:
            if k not in seen and not k.startswith("_"):
                yield k

    def __len__(self) -> int:
        return sum(1 for _ in self)


@dataclass
class TemplateSchema(BaseSchema):
    BACKEND: TemplateBackendType | str
    """
    The template backend to use.
    """
    DIRS: list[str | Path] = field(default_factory=list)
    """
    Directories where the engine should look for template source files, in search order.
    """
    APP_DIRS: bool = False
    """
    Whether the engine should look for template source files inside installed applications.
    """
    OPTIONS: dict[str, Any] = field(default_factory=dict)
    """
    Extra parameters to pass to the template backend.
    """
    NAME: str | None = None
    """
    The alias for this particular template engine.
    """


@dataclass
class DatabaseSchema(BaseSchema):
    ENGINE: DatabaseEngineType | str
    """
    The database backend to use.
    """
    NAME: str | Path
    """
    The name of the database to use.
    """
    USER: str | None = None
    """
    The username to use when connecting to the database.
    """
    PASSWORD: str | None = None
    """
    The password to use when connecting to the database.
    """
    HOST: str | None = None
    """
    Which host to use when connecting to the database.
    """
    PORT: str | int | None = None
    """
    The port to use when connecting to the database.
    """
    ATOMIC_REQUESTS: bool = False
    """
    Set this to True to wrap each view in a transaction on this database.
    """
    AUTOCOMMIT: bool = True
    """
    Set this to False if you want to disable Django's transaction management and implement your own.
    """
    CONN_MAX_AGE: int = 0
    """
    The lifetime of a database connection, as an integer of seconds.
    """
    OPTIONS: dict[str, Any] = field(default_factory=dict)
    """
    Extra parameters to use when connecting to the database.
    """
    TIME_ZONE: str | None = None
    """
    A string representing the time zone for this database connection or None.
    """
    TEST: dict[str, Any] = field(default_factory=dict)
    """
    A dictionary of settings for test databases.
    """
    CONN_HEALTH_CHECKS: bool = False
    """
    If set to True, existing persistent database connections will be health checked before they are reused.
    """


@dataclass
class CacheSchema(BaseSchema):
    BACKEND: CacheBackendType | str
    """
    The cache backend to use.
    """
    LOCATION: str | None = None
    """
    The location of the cache to use.
    """
    TIMEOUT: int | None = None
    """
    The number of seconds before a cache entry is considered stale.
    """
    OPTIONS: dict[str, Any] = field(default_factory=dict)
    """
    Extra parameters to pass to the cache backend.
    """
    KEY_PREFIX: str | None = None
    """
    A string that will be automatically included (prepended by default) to all cache keys used by the Django server.
    """
    KEY_FUNCTION: str | None = None
    """
    A string containing a dotted path to a function (or any callable)
    that defines how to compose a prefix, version and key into a final
    cache key.
    """
    VERSION: int | None = None
    """
    The default version number for cache keys generated by the Django server.
    """


@dataclass
class AuthPasswordValidatorSchema(BaseSchema):
    NAME: AuthPasswordValidatorNameType | str
    """
    The dotted path to the password validator class.
    """
    OPTIONS: dict[str, Any] = field(default_factory=dict)
    """
    Optional parameters for the password validator.
    """


@dataclass
class TaskSchema(BaseSchema):
    BACKEND: TaskBackendType | str
    """
    The Tasks backend to use.
    """
    QUEUES: list[str] | tuple[str, ...] = field(default_factory=lambda: ["default"])
    """
    Specify the queue names supported by the backend.
    """
    OPTIONS: dict[str, Any] = field(default_factory=dict)
    """
    Extra parameters to pass to the Task backend.
    """


@dataclass
class SettingsSchema(BaseSchema):
    SECRET_KEY: str | None
    r"""
    A secret key for this particular Django installation. Used in secret-key
    hashing algorithms. Set this in your settings, or Django will complain
    loudly.
    """
    DEBUG: bool = False
    r"""
    A boolean that turns on/off debug mode.
    """
    DEBUG_PROPAGATE_EXCEPTIONS: bool = False
    r"""
    Whether the framework should propagate raw exceptions rather than catching
    them. This is useful under some testing situations and should never be used
    on a live site.
    """
    ADMINS: list[tuple[str, str]] | tuple[tuple[str, str], ...] = field(default_factory=list)
    r"""
    People who get code error notifications. In the format
    ["email@example.com", '"Full Name" <anotheremail@example.com>']
    """
    INTERNAL_IPS: list | tuple = field(default_factory=list)
    r"""
    List of IP addresses, as strings, that:
    * See debug comments, when DEBUG is true
    * Receive x-headers
    """
    ALLOWED_HOSTS: list | tuple = field(default_factory=list)
    r"""
    Hosts/domain names that are valid for this site.
    "*" matches anything, ".example.com" matches example.com and all subdomains
    """
    TIME_ZONE: str = "America/Chicago"
    r"""
    Local time zone for this installation. All choices can be found here:
    https://en.wikipedia.org/wiki/List_of_tz_zones_by_name (although not all
    systems may support all possibilities). When USE_TZ is True, this is
    interpreted as the default user time zone.
    """
    USE_TZ: bool = True
    r"""
    If you set this to True, Django will use timezone-aware datetimes.
    """
    LANGUAGE_CODE: str = "en-us"
    r"""
    Language code for this installation. Valid choices can be found here:
    https://www.iana.org/assignments/language-subtag-registry/
    If LANGUAGE_CODE is not listed in LANGUAGES (below), the project must
    provide the necessary translations and locale definitions.
    """
    LANGUAGES: list | tuple = field(default_factory=list)
    r"""
    A list of all available languages. The list is a list of two-tuples in the
    format (language code, language name) - for example, ('ja', 'Japanese').
    This setting is used to determine which languages are available for language
    selection.
    """
    LANGUAGES_BIDI: list | tuple = field(default_factory=list)
    r"""
    Languages using BiDi (right-to-left) layout
    """
    USE_I18N: bool = True
    r"""
    If you set this to False, Django will make some optimizations so as not
    to load the internationalization machinery.
    """
    LOCALE_PATHS: list[str | Path] | tuple[str | Path, ...] = field(default_factory=list)
    LANGUAGE_COOKIE_NAME: str = "django_language"
    r"""
    Settings for language cookie
    """
    LANGUAGE_COOKIE_AGE: int | None = None
    LANGUAGE_COOKIE_DOMAIN: str | None = None
    LANGUAGE_COOKIE_PATH: str = "/"
    LANGUAGE_COOKIE_SECURE: bool = False
    LANGUAGE_COOKIE_HTTPONLY: bool = False
    LANGUAGE_COOKIE_SAMESITE: str | None = None
    MANAGERS: list[tuple[str, str]] | tuple[tuple[str, str], ...] = field(default_factory=list)
    r"""
    Not-necessarily-technical managers of the site. They get broken link
    notifications and other various emails.
    """
    DEFAULT_CHARSET: str = "utf-8"
    r"""
    Default charset to use for all HttpResponse objects, if a MIME type isn't
    manually specified. It's used to construct the Content-Type header.
    """
    SERVER_EMAIL: str = "root@localhost"
    r"""
    Email address that error messages come from.
    """
    DATABASES: dict[str, DatabaseSchema] = field(default_factory=dict)
    r"""
    Database connection info. If left empty, will default to the dummy backend.
    """
    DATABASE_ROUTERS: list | tuple = field(default_factory=list)
    r"""
    Classes used to implement DB routing behavior.
    """
    EMAIL_BACKEND: str = "django.core.mail.backends.smtp.EmailBackend"
    r"""
    The email backend to use. For possible shortcuts see django.core.mail.
    The default is to use the SMTP backend.
    Third-party backends can be specified by providing a Python path
    to a module that defines an EmailBackend class.
    """
    EMAIL_HOST: str = "localhost"
    r"""
    Host for sending email.
    """
    EMAIL_PORT: int = 25
    r"""
    Port for sending email.
    """
    EMAIL_USE_LOCALTIME: bool = False
    r"""
    Whether to send SMTP 'Date' header in the local time zone or in UTC.
    """
    EMAIL_HOST_USER: str = ""
    r"""
    Optional SMTP authentication information for EMAIL_HOST.
    """
    EMAIL_HOST_PASSWORD: str = ""
    EMAIL_USE_TLS: bool = False
    EMAIL_USE_SSL: bool = False
    EMAIL_SSL_CERTFILE: str | None = None
    EMAIL_SSL_KEYFILE: str | None = None
    EMAIL_TIMEOUT: int | None = None
    INSTALLED_APPS: list[str] | tuple[str, ...] = field(default_factory=list)
    r"""
    List of strings representing installed apps.
    """
    TEMPLATES: list[TemplateSchema] | tuple[TemplateSchema, ...] = field(default_factory=list)
    FORM_RENDERER: str = "django.forms.renderers.DjangoTemplates"
    r"""
    Default form rendering class.
    """
    DEFAULT_FROM_EMAIL: str = "webmaster@localhost"
    r"""
    Default email address to use for various automated correspondence from
    the site managers.
    """
    EMAIL_SUBJECT_PREFIX: str = "[Django] "
    r"""
    Subject-line prefix for email messages send with django.core.mail.mail_admins
    or ...mail_managers. Make sure to include the trailing space.
    """
    APPEND_SLASH: bool = True
    r"""
    Whether to append trailing slashes to URLs.
    """
    PREPEND_WWW: bool = False
    r"""
    Whether to prepend the "www." subdomain to URLs that don't have it.
    """
    FORCE_SCRIPT_NAME: str | None = None
    r"""
    Override the server-derived value of SCRIPT_NAME
    """
    DISALLOWED_USER_AGENTS: list | tuple = field(default_factory=list)
    r"""
    List of compiled regular expression objects representing User-Agent strings
    that are not allowed to visit any page, systemwide. Use this for bad
    robots/crawlers. Here are a few examples:
    import re
    DISALLOWED_USER_AGENTS = [
    re.compile(r'^NaverBot.*'),
    re.compile(r'^EmailSiphon.*'),
    re.compile(r'^SiteSucker.*'),
    re.compile(r'^sohu-search'),
    ]
    """
    ABSOLUTE_URL_OVERRIDES: dict = field(default_factory=dict)
    IGNORABLE_404_URLS: list | tuple = field(default_factory=list)
    r"""
    List of compiled regular expression objects representing URLs that need not
    be reported by BrokenLinkEmailsMiddleware. Here are a few examples:
    import re
    IGNORABLE_404_URLS = [
    re.compile(r'^/apple-touch-icon.*\.png$'),
    re.compile(r'^/favicon.ico$'),
    re.compile(r'^/robots.txt$'),
    re.compile(r'^/phpmyadmin/'),
    re.compile(r'\.(cgi|php|pl)$'),
    ]
    """
    SECRET_KEY_FALLBACKS: list | tuple = field(default_factory=list)
    r"""
    List of secret keys used to verify the validity of signatures. This allows
    secret key rotation.
    """
    STORAGES: dict = field(default_factory=dict)
    MEDIA_ROOT: str | Path | None = ""
    r"""
    Absolute filesystem path to the directory that will hold user-uploaded files.
    Example: "/var/www/example.com/media/"
    """
    MEDIA_URL: str | None = ""
    r"""
    URL that handles the media served from MEDIA_ROOT.
    Examples: "http://example.com/media/", "http://media.example.com/"
    """
    STATIC_ROOT: str | Path | None = None
    r"""
    Absolute path to the directory static files should be collected to.
    Example: "/var/www/example.com/static/"
    """
    STATIC_URL: str | None = None
    r"""
    URL that handles the static files served from STATIC_ROOT.
    Example: "http://example.com/static/", "http://static.example.com/"
    """
    FILE_UPLOAD_HANDLERS: list | tuple = field(default_factory=list)
    r"""
    List of upload handler classes to be applied in order.
    """
    FILE_UPLOAD_MAX_MEMORY_SIZE: int = 2621440
    r"""
    Maximum size, in bytes, of a request before it will be streamed to the
    file system instead of into memory.
    """
    DATA_UPLOAD_MAX_MEMORY_SIZE: int = 2621440
    r"""
    Maximum size in bytes of request data (excluding file uploads) that will be
    read before a SuspiciousOperation (RequestDataTooBig) is raised.
    """
    DATA_UPLOAD_MAX_NUMBER_FIELDS: int = 1000
    r"""
    Maximum number of GET/POST parameters that will be read before a
    SuspiciousOperation (TooManyFieldsSent) is raised.
    """
    DATA_UPLOAD_MAX_NUMBER_FILES: int = 100
    r"""
    Maximum number of files encoded in a multipart upload that will be read
    before a SuspiciousOperation (TooManyFilesSent) is raised.
    """
    FILE_UPLOAD_TEMP_DIR: str | Path | None = None
    r"""
    Directory in which upload streamed files will be temporarily saved. A value
    of `None` will make Django use the operating system's default temporary
    directory (i.e. "/tmp" on *nix systems).
    """
    FILE_UPLOAD_PERMISSIONS: int = 420
    r"""
    The numeric mode to set newly-uploaded files to. The value should be a mode
    you'd pass directly to os.chmod; see
    https://docs.python.org/library/os.html#files-and-directories.
    """
    FILE_UPLOAD_DIRECTORY_PERMISSIONS: int | None = None
    r"""
    The numeric mode to assign to newly-created directories, when uploading
    files. The value should be a mode as you'd pass to os.chmod; see
    https://docs.python.org/library/os.html#files-and-directories.
    """
    FORMAT_MODULE_PATH: str | None = None
    r"""
    Python module path where user will place custom format definition.
    The directory where this setting is pointing should contain subdirectories
    named as the locales, containing a formats.py file
    (i.e. "myproject.locale" for myproject/locale/en/formats.py etc. use)
    """
    DATE_FORMAT: str = "N j, Y"
    r"""
    Default formatting for date objects. See all available format strings here:
    https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
    """
    DATETIME_FORMAT: str = "N j, Y, P"
    r"""
    Default formatting for datetime objects. See all available format strings
    here: https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
    """
    TIME_FORMAT: str = "P"
    r"""
    Default formatting for time objects. See all available format strings here:
    https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
    """
    YEAR_MONTH_FORMAT: str = "F Y"
    r"""
    Default formatting for date objects when only the year and month are
    relevant. See all available format strings here:
    https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
    """
    MONTH_DAY_FORMAT: str = "F j"
    r"""
    Default formatting for date objects when only the month and day are relevant.
    See all available format strings here:
    https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
    """
    SHORT_DATE_FORMAT: str = "m/d/Y"
    r"""
    Default short formatting for date objects. See all available format strings
    here: https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
    """
    SHORT_DATETIME_FORMAT: str = "m/d/Y P"
    r"""
    Default short formatting for datetime objects.
    See all available format strings here:
    https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
    """
    DATE_INPUT_FORMATS: list | tuple = field(default_factory=list)
    r"""
    Default formats to be used when parsing dates from input boxes, in order
    See all available format string here:
    https://docs.python.org/library/datetime.html#strftime-behavior
    * Note that these format strings are different from the ones to display dates
    """
    TIME_INPUT_FORMATS: list | tuple = field(default_factory=list)
    r"""
    Default formats to be used when parsing times from input boxes, in order
    See all available format string here:
    https://docs.python.org/library/datetime.html#strftime-behavior
    * Note that these format strings are different from the ones to display dates
    """
    DATETIME_INPUT_FORMATS: list | tuple = field(default_factory=list)
    r"""
    Default formats to be used when parsing dates and times from input boxes,
    in order
    See all available format string here:
    https://docs.python.org/library/datetime.html#strftime-behavior
    * Note that these format strings are different from the ones to display dates
    """
    FIRST_DAY_OF_WEEK: int = 0
    r"""
    First day of week, to be used on calendars
    0 means Sunday, 1 means Monday...
    """
    DECIMAL_SEPARATOR: str = "."
    r"""
    Decimal separator symbol
    """
    USE_THOUSAND_SEPARATOR: bool = False
    r"""
    Boolean that sets whether to add thousand separator when formatting numbers
    """
    NUMBER_GROUPING: int = 0
    r"""
    Number of digits that will be together, when splitting them by
    THOUSAND_SEPARATOR. 0 means no grouping, 3 means splitting by thousands...
    """
    THOUSAND_SEPARATOR: str = ","
    r"""
    Thousand separator symbol
    """
    DEFAULT_TABLESPACE: str = ""
    r"""
    The tablespaces to use for each model when not specified otherwise.
    """
    DEFAULT_INDEX_TABLESPACE: str = ""
    DEFAULT_AUTO_FIELD: str = "django.db.models.BigAutoField"
    r"""
    Default primary key field type.
    """
    X_FRAME_OPTIONS: str = "DENY"
    r"""
    Default X-Frame-Options header value
    """
    USE_X_FORWARDED_HOST: bool = False
    USE_X_FORWARDED_PORT: bool = False
    WSGI_APPLICATION: str | None = None
    r"""
    The Python dotted path to the WSGI application that Django's internal server
    (runserver) will use. If `None`, the return value of
    'django.core.wsgi.get_wsgi_application' is used, thus preserving the same
    behavior as previous versions of Django. Otherwise this should point to an
    actual WSGI application object.
    """
    SECURE_PROXY_SSL_HEADER: tuple | list | None = field(default_factory=list)
    r"""
    If your Django app is behind a proxy that sets a header to specify secure
    connections, AND that proxy ensures that user-submitted headers with the
    same name are ignored (so that people can't spoof it), set this value to
    a tuple of (header_name, header_value). For any requests that come in with
    that header/value, request.is_secure() will return True.
    WARNING! Only set this if you fully understand what you're doing. Otherwise,
    you may be opening yourself up to a security risk.
    """
    MIDDLEWARE: list[str] | tuple[str, ...] = field(default_factory=list)
    r"""
    List of middleware to use. Order is important; in the request phase, these
    middleware will be applied in the order given, and in the response
    phase the middleware will be applied in reverse order.
    """
    SESSION_CACHE_ALIAS: str = "default"
    r"""
    Cache to store session data if using the cache session backend.
    """
    SESSION_COOKIE_NAME: str = "sessionid"
    r"""
    Cookie name. This can be whatever you want.
    """
    SESSION_COOKIE_AGE: int | None = None
    r"""
    Age of cookie, in seconds (default: 2 weeks).
    """
    SESSION_COOKIE_DOMAIN: Any | None = None
    r"""
    A string like "example.com", or None for standard domain cookie.
    """
    SESSION_COOKIE_SECURE: bool = False
    r"""
    Whether the session cookie should be secure (https:// only).
    """
    SESSION_COOKIE_PATH: str = "/"
    r"""
    The path of the session cookie.
    """
    SESSION_COOKIE_HTTPONLY: bool = True
    r"""
    Whether to use the HttpOnly flag.
    """
    SESSION_COOKIE_SAMESITE: str = "Lax"
    r"""
    Whether to set the flag restricting cookie leaks on cross-site requests.
    This can be 'Lax', 'Strict', 'None', or False to disable the flag.
    """
    SESSION_SAVE_EVERY_REQUEST: bool = False
    r"""
    Whether to save the session data on every request.
    """
    SESSION_EXPIRE_AT_BROWSER_CLOSE: bool = False
    r"""
    Whether a user's session cookie expires when the web browser is closed.
    """
    SESSION_ENGINE: str = "django.contrib.sessions.backends.db"
    r"""
    The module to store session data
    """
    SESSION_FILE_PATH: str | Path | None = None
    r"""
    Directory to store session files if using the file session module. If None,
    the backend will use a sensible default.
    """
    SESSION_SERIALIZER: str = "django.contrib.sessions.serializers.JSONSerializer"
    r"""
    class to serialize session data
    """
    CACHES: dict[str, CacheSchema] = field(default_factory=dict)
    r"""
    The cache backends to use.
    """
    CACHE_MIDDLEWARE_KEY_PREFIX: str = ""
    CACHE_MIDDLEWARE_SECONDS: int = 600
    CACHE_MIDDLEWARE_ALIAS: str = "default"
    AUTH_USER_MODEL: str = "auth.User"
    AUTHENTICATION_BACKENDS: list[str] | tuple[str, ...] = field(default_factory=list)
    LOGIN_URL: str = "/accounts/login/"
    LOGIN_REDIRECT_URL: str = "/accounts/profile/"
    LOGOUT_REDIRECT_URL: str | None = None
    PASSWORD_RESET_TIMEOUT: int | None = None
    r"""
    The number of seconds a password reset link is valid for (default: 3 days).
    """
    PASSWORD_HASHERS: list | tuple = field(default_factory=list)
    r"""
    The first hasher in this list is the preferred algorithm. Any password using
    different algorithms will be converted automatically upon login.
    """
    AUTH_PASSWORD_VALIDATORS: list[AuthPasswordValidatorSchema] | tuple[AuthPasswordValidatorSchema, ...] = field(
        default_factory=list
    )
    SIGNING_BACKEND: str = "django.core.signing.TimestampSigner"
    CSRF_FAILURE_VIEW: str = "django.views.csrf.csrf_failure"
    r"""
    Dotted path to callable to be used as view when a request is
    rejected by the CSRF middleware.
    """
    CSRF_COOKIE_NAME: str = "csrftoken"
    r"""
    Settings for CSRF cookie.
    """
    CSRF_COOKIE_AGE: int | None = None
    CSRF_COOKIE_DOMAIN: str | None = None
    CSRF_COOKIE_PATH: str = "/"
    CSRF_COOKIE_SECURE: bool = False
    CSRF_COOKIE_HTTPONLY: bool = False
    CSRF_COOKIE_SAMESITE: str = "Lax"
    CSRF_HEADER_NAME: str = "HTTP_X_CSRFTOKEN"
    CSRF_TRUSTED_ORIGINS: list | tuple = field(default_factory=list)
    CSRF_USE_SESSIONS: bool = False
    MESSAGE_STORAGE: str = "django.contrib.messages.storage.fallback.FallbackStorage"
    r"""
    Class to use as messages backend
    """
    LOGGING_CONFIG: str = "logging.config.dictConfig"
    r"""
    The callable to use to configure logging
    """
    LOGGING: dict = field(default_factory=dict)
    r"""
    Custom logging configuration.
    """
    DEFAULT_EXCEPTION_REPORTER: str = "django.views.debug.ExceptionReporter"
    r"""
    Default exception reporter class used in case none has been
    specifically assigned to the HttpRequest instance.
    """
    DEFAULT_EXCEPTION_REPORTER_FILTER: str = "django.views.debug.SafeExceptionReporterFilter"
    r"""
    Default exception reporter filter class used in case none has been
    specifically assigned to the HttpRequest instance.
    """
    TEST_RUNNER: str = "django.test.runner.DiscoverRunner"
    r"""
    The name of the class to use to run the test suite
    """
    TEST_NON_SERIALIZED_APPS: list | tuple = field(default_factory=list)
    r"""
    Apps that don't need to be serialized at test database creation time
    (only apps with migrations are to start with)
    """
    FIXTURE_DIRS: list[str | Path] | tuple[str | Path, ...] = field(default_factory=list)
    r"""
    The list of directories to search for fixtures
    """
    STATICFILES_DIRS: list[str | Path] | tuple[str | Path, ...] = field(default_factory=list)
    r"""
    A list of locations of additional static files
    """
    STATICFILES_FINDERS: list | tuple = field(default_factory=list)
    r"""
    List of finder classes that know how to find static files in
    various locations.
    """
    MIGRATION_MODULES: dict = field(default_factory=dict)
    r"""
    Migration module overrides for apps, by app label.
    """
    SILENCED_SYSTEM_CHECKS: list | tuple = field(default_factory=list)
    r"""
    List of all issues generated by system checks that should be silenced. Light
    issues like warnings, infos or debugs will not generate a message. Silencing
    serious issues like errors and criticals does not result in hiding the
    message, but Django will not stop you from e.g. running server.
    """
    SECURE_CONTENT_TYPE_NOSNIFF: bool = True
    SECURE_CROSS_ORIGIN_OPENER_POLICY: str = "same-origin"
    SECURE_HSTS_INCLUDE_SUBDOMAINS: bool = False
    SECURE_HSTS_PRELOAD: bool = False
    SECURE_HSTS_SECONDS: int = 0
    SECURE_REDIRECT_EXEMPT: list | tuple = field(default_factory=list)
    SECURE_REFERRER_POLICY: str = "same-origin"
    SECURE_SSL_HOST: str | None = None
    SECURE_SSL_REDIRECT: bool = False
    SECURE_CSP: dict = field(default_factory=dict)
    SECURE_CSP_REPORT_ONLY: dict = field(default_factory=dict)
    URLIZE_ASSUME_HTTPS: bool = False
    r"""
    RemovedInDjango70Warning: A transitional setting helpful in early adoption of
    HTTPS as the default protocol in urlize and urlizetrunc when no protocol is
    provided. Set to True to assume HTTPS during the Django 6.x release cycle.
    """
    TASKS: dict[str, TaskSchema] = field(default_factory=dict)
