"""
This type stub file was generated by pyright.
"""

from dataclasses import dataclass
from typing import Literal, TYPE_CHECKING, Union, overload
from typing_extensions import TypeAlias
from streamlit.elements.lib.utils import Key, LabelVisibility
from streamlit.proto.Common_pb2 import FileUploaderState as FileUploaderStateProto
from streamlit.runtime.metrics_util import gather_metrics
from streamlit.runtime.state import WidgetArgs, WidgetCallback, WidgetKwargs
from streamlit.runtime.uploaded_file_manager import DeletedFile, UploadedFile
from collections.abc import Sequence
from streamlit.delta_generator import DeltaGenerator

if TYPE_CHECKING:
    ...
SomeUploadedFiles: TypeAlias = Union[UploadedFile, DeletedFile, list[Union[UploadedFile, DeletedFile]], None,]
@dataclass
class FileUploaderSerde:
    accept_multiple_files: bool
    allowed_types: Sequence[str] | None = ...
    def deserialize(self, ui_value: FileUploaderStateProto | None, widget_id: str) -> SomeUploadedFiles:
        ...
    
    def serialize(self, files: SomeUploadedFiles) -> FileUploaderStateProto:
        ...
    


class FileUploaderMixin:
    @overload
    def file_uploader(self, label: str, type: str | Sequence[str] | None, accept_multiple_files: Literal[True], key: Key | None = ..., help: str | None = ..., on_change: WidgetCallback | None = ..., args: WidgetArgs | None = ..., kwargs: WidgetKwargs | None = ..., *, disabled: bool = ..., label_visibility: LabelVisibility = ...) -> list[UploadedFile] | None:
        ...
    
    @overload
    def file_uploader(self, label: str, type: str | Sequence[str] | None, accept_multiple_files: Literal[False] = ..., key: Key | None = ..., help: str | None = ..., on_change: WidgetCallback | None = ..., args: WidgetArgs | None = ..., kwargs: WidgetKwargs | None = ..., *, disabled: bool = ..., label_visibility: LabelVisibility = ...) -> UploadedFile | None:
        ...
    
    @overload
    def file_uploader(self, label: str, *, accept_multiple_files: Literal[True], type: str | Sequence[str] | None = ..., key: Key | None = ..., help: str | None = ..., on_change: WidgetCallback | None = ..., args: WidgetArgs | None = ..., kwargs: WidgetKwargs | None = ..., disabled: bool = ..., label_visibility: LabelVisibility = ...) -> list[UploadedFile] | None:
        ...
    
    @overload
    def file_uploader(self, label: str, *, accept_multiple_files: Literal[False] = ..., type: str | Sequence[str] | None = ..., key: Key | None = ..., help: str | None = ..., on_change: WidgetCallback | None = ..., args: WidgetArgs | None = ..., kwargs: WidgetKwargs | None = ..., disabled: bool = ..., label_visibility: LabelVisibility = ...) -> UploadedFile | None:
        ...
    
    @gather_metrics("file_uploader")
    def file_uploader(self, label: str, type: str | Sequence[str] | None = ..., accept_multiple_files: bool = ..., key: Key | None = ..., help: str | None = ..., on_change: WidgetCallback | None = ..., args: WidgetArgs | None = ..., kwargs: WidgetKwargs | None = ..., *, disabled: bool = ..., label_visibility: LabelVisibility = ...) -> UploadedFile | list[UploadedFile] | None:
        r"""Display a file uploader widget.
        By default, uploaded files are limited to 200 MB each. You can
        configure this using the ``server.maxUploadSize`` config option. For
        more information on how to set config options, see |config.toml|_.

        .. |config.toml| replace:: ``config.toml``
        .. _config.toml: https://docs.streamlit.io/develop/api-reference/configuration/config.toml

        Parameters
        ----------
        label : str
            A short label explaining to the user what this file uploader is for.
            The label can optionally contain GitHub-flavored Markdown of the
            following types: Bold, Italics, Strikethroughs, Inline Code, Links,
            and Images. Images display like icons, with a max height equal to
            the font height.

            Unsupported Markdown elements are unwrapped so only their children
            (text contents) render. Display unsupported elements as literal
            characters by backslash-escaping them. E.g.,
            ``"1\. Not an ordered list"``.

            See the ``body`` parameter of |st.markdown|_ for additional,
            supported Markdown directives.

            For accessibility reasons, you should never set an empty label, but
            you can hide it with ``label_visibility`` if needed. In the future,
            we may disallow empty labels by raising an exception.

            .. |st.markdown| replace:: ``st.markdown``
            .. _st.markdown: https://docs.streamlit.io/develop/api-reference/text/st.markdown

        type : str or list of str or None
            The allowed file extension(s) for uploaded files. This can be one
            of the following types:

            - ``None`` (default): All file extensions are allowed.
            - A string: A single file extension is allowed. For example, to
              only accept CSV files, use ``"csv"``.
            - A sequence of strings: Multiple file extensions are allowed. For
              example, to only accept JPG/JPEG and PNG files, use
              ``["jpg", "jpeg", "png"]``.

        accept_multiple_files : bool
            Whether to accept more than one file in a submission. If this is
            ``False`` (default), the user can only submit one file at a time.
            If this is ``True``, the user can upload multiple files at the same
            time, in which case the return value will be a list of files.

        key : str or int
            An optional string or integer to use as the unique key for the widget.
            If this is omitted, a key will be generated for the widget
            based on its content. No two widgets may have the same key.

        help : str or None
            A tooltip that gets displayed next to the widget label. Streamlit
            only displays the tooltip when ``label_visibility="visible"``. If
            this is ``None`` (default), no tooltip is displayed.

            The tooltip can optionally contain GitHub-flavored Markdown,
            including the Markdown directives described in the ``body``
            parameter of ``st.markdown``.

        on_change : callable
            An optional callback invoked when this file_uploader's value
            changes.

        args : tuple
            An optional tuple of args to pass to the callback.

        kwargs : dict
            An optional dict of kwargs to pass to the callback.

        disabled : bool
            An optional boolean that disables the file uploader if set to
            ``True``. The default is ``False``.

        label_visibility : "visible", "hidden", or "collapsed"
            The visibility of the label. The default is ``"visible"``. If this
            is ``"hidden"``, Streamlit displays an empty spacer instead of the
            label, which can help keep the widget alligned with other widgets.
            If this is ``"collapsed"``, Streamlit displays no label or spacer.

        Returns
        -------
        None, UploadedFile, or list of UploadedFile
            - If accept_multiple_files is False, returns either None or
              an UploadedFile object.
            - If accept_multiple_files is True, returns a list with the
              uploaded files as UploadedFile objects. If no files were
              uploaded, returns an empty list.

            The UploadedFile class is a subclass of BytesIO, and therefore is
            "file-like". This means you can pass an instance of it anywhere a
            file is expected.

        Examples
        --------
        Insert a file uploader that accepts a single file at a time:

        >>> import streamlit as st
        >>> import pandas as pd
        >>> from io import StringIO
        >>>
        >>> uploaded_file = st.file_uploader("Choose a file")
        >>> if uploaded_file is not None:
        ...     # To read file as bytes:
        ...     bytes_data = uploaded_file.getvalue()
        ...     st.write(bytes_data)
        >>>
        ...     # To convert to a string based IO:
        ...     stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
        ...     st.write(stringio)
        >>>
        ...     # To read file as string:
        ...     string_data = stringio.read()
        ...     st.write(string_data)
        >>>
        ...     # Can be used wherever a "file-like" object is accepted:
        ...     dataframe = pd.read_csv(uploaded_file)
        ...     st.write(dataframe)

        Insert a file uploader that accepts multiple files at a time:

        >>> import streamlit as st
        >>>
        >>> uploaded_files = st.file_uploader(
        ...     "Choose a CSV file", accept_multiple_files=True
        ... )
        >>> for uploaded_file in uploaded_files:
        ...     bytes_data = uploaded_file.read()
        ...     st.write("filename:", uploaded_file.name)
        ...     st.write(bytes_data)

        .. output::
           https://doc-file-uploader.streamlit.app/
           height: 375px

        """
        ...
    
    @property
    def dg(self) -> DeltaGenerator:
        """Get our DeltaGenerator."""
        ...
    


