# -*- coding: utf-8 -*-
# Auto-generated by Stone, do not modify.
# @generated
# flake8: noqa
# pylint: skip-file
"""
This namespace contains endpoints and data types for basic file operations.
"""

from __future__ import unicode_literals
from stone.backends.python_rsrc import stone_base as bb
from stone.backends.python_rsrc import stone_validators as bv

from dropbox import async_
from dropbox import common
from dropbox import file_properties
from dropbox import users_common


class AddTagArg(bb.Struct):
    """
    :ivar AddTagArg.path:
        Path to the item to be tagged.
    :ivar AddTagArg.tag_text:
        The value of the tag to add. Will be automatically converted to
        lowercase letters.
    """

    __slots__ = [
        "_path_value",
        "_tag_text_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, tag_text=None):
        self._path_value = bb.NOT_SET
        self._tag_text_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if tag_text is not None:
            self.tag_text = tag_text

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: str (validator is set below)
    tag_text = bb.Attribute("tag_text")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(AddTagArg, self)._process_custom_annotations(annotation_type, field_path, processor)


AddTagArg_validator = bv.Struct(AddTagArg)


class BaseTagError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: BaseTagError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(BaseTagError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


BaseTagError_validator = bv.Union(BaseTagError)


class AddTagError(BaseTagError):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar AddTagError.too_many_tags:
        The item already has the maximum supported number of tags.
    """

    # Attribute is overwritten below the class definition
    too_many_tags = None

    def is_too_many_tags(self):
        """
        Check if the union tag is ``too_many_tags``.

        :rtype: bool
        """
        return self._tag == "too_many_tags"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(AddTagError, self)._process_custom_annotations(annotation_type, field_path, processor)


AddTagError_validator = bv.Union(AddTagError)


class GetMetadataArg(bb.Struct):
    """
    :ivar GetMetadataArg.path:
        The path of a file or folder on Dropbox.
    :ivar GetMetadataArg.include_media_info:
        If true, ``FileMetadata.media_info`` is set for photo and video.
    :ivar GetMetadataArg.include_deleted:
        If true, :class:`DeletedMetadata` will be returned for deleted file or
        folder, otherwise ``LookupError.not_found`` will be returned.
    :ivar GetMetadataArg.include_has_explicit_shared_members:
        If true, the results will include a flag for each file indicating
        whether or not that file has any explicit members.
    :ivar GetMetadataArg.include_property_groups:
        If set to a valid list of template IDs, ``FileMetadata.property_groups``
        is set if there exists property data associated with the file and each
        of the listed templates.
    """

    __slots__ = [
        "_path_value",
        "_include_media_info_value",
        "_include_deleted_value",
        "_include_has_explicit_shared_members_value",
        "_include_property_groups_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        path=None,
        include_media_info=None,
        include_deleted=None,
        include_has_explicit_shared_members=None,
        include_property_groups=None,
    ):
        self._path_value = bb.NOT_SET
        self._include_media_info_value = bb.NOT_SET
        self._include_deleted_value = bb.NOT_SET
        self._include_has_explicit_shared_members_value = bb.NOT_SET
        self._include_property_groups_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if include_media_info is not None:
            self.include_media_info = include_media_info
        if include_deleted is not None:
            self.include_deleted = include_deleted
        if include_has_explicit_shared_members is not None:
            self.include_has_explicit_shared_members = include_has_explicit_shared_members
        if include_property_groups is not None:
            self.include_property_groups = include_property_groups

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: bool (validator is set below)
    include_media_info = bb.Attribute("include_media_info")

    # Instance attribute type: bool (validator is set below)
    include_deleted = bb.Attribute("include_deleted")

    # Instance attribute type: bool (validator is set below)
    include_has_explicit_shared_members = bb.Attribute("include_has_explicit_shared_members")

    # Instance attribute type: file_properties.TemplateFilterBase (validator is set below)
    include_property_groups = bb.Attribute(
        "include_property_groups", nullable=True, user_defined=True
    )

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetMetadataArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetMetadataArg_validator = bv.Struct(GetMetadataArg)


class AlphaGetMetadataArg(GetMetadataArg):
    """
    :ivar AlphaGetMetadataArg.include_property_templates:
        Field is deprecated. If set to a valid list of template IDs,
        ``FileMetadata.property_groups`` is set for files with custom
        properties.
    """

    __slots__ = [
        "_include_property_templates_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        path=None,
        include_media_info=None,
        include_deleted=None,
        include_has_explicit_shared_members=None,
        include_property_groups=None,
        include_property_templates=None,
    ):
        super(AlphaGetMetadataArg, self).__init__(
            path,
            include_media_info,
            include_deleted,
            include_has_explicit_shared_members,
            include_property_groups,
        )
        self._include_property_templates_value = bb.NOT_SET
        if include_property_templates is not None:
            self.include_property_templates = include_property_templates

    # Instance attribute type: list of [str] (validator is set below)
    include_property_templates = bb.Attribute("include_property_templates", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(AlphaGetMetadataArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


AlphaGetMetadataArg_validator = bv.Struct(AlphaGetMetadataArg)


class GetMetadataError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: GetMetadataError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetMetadataError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetMetadataError_validator = bv.Union(GetMetadataError)


class AlphaGetMetadataError(GetMetadataError):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    @classmethod
    def properties_error(cls, val):
        """
        Create an instance of this class set to the ``properties_error`` tag
        with value ``val``.

        :param file_properties.LookUpPropertiesError val:
        :rtype: AlphaGetMetadataError
        """
        return cls("properties_error", val)

    def is_properties_error(self):
        """
        Check if the union tag is ``properties_error``.

        :rtype: bool
        """
        return self._tag == "properties_error"

    def get_properties_error(self):
        """
        Only call this if :meth:`is_properties_error` is true.

        :rtype: file_properties.LookUpPropertiesError
        """
        if not self.is_properties_error():
            raise AttributeError("tag 'properties_error' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(AlphaGetMetadataError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


AlphaGetMetadataError_validator = bv.Union(AlphaGetMetadataError)


class CommitInfo(bb.Struct):
    """
    :ivar CommitInfo.path:
        Path in the user's Dropbox to save the file.
    :ivar CommitInfo.mode:
        Selects what to do if the file already exists.
    :ivar CommitInfo.autorename:
        If there's a conflict, as determined by ``mode``, have the Dropbox
        server try to autorename the file to avoid conflict.
    :ivar CommitInfo.client_modified:
        The value to store as the ``client_modified`` timestamp. Dropbox
        automatically records the time at which the file was written to the
        Dropbox servers. It can also record an additional timestamp, provided by
        Dropbox desktop clients, mobile clients, and API apps of when the file
        was actually created or modified.
    :ivar CommitInfo.mute:
        Normally, users are made aware of any file modifications in their
        Dropbox account via notifications in the client software. If ``True``,
        this tells the clients that this modification shouldn't result in a user
        notification.
    :ivar CommitInfo.property_groups:
        List of custom properties to add to file.
    :ivar CommitInfo.strict_conflict:
        Be more strict about how each :class:`WriteMode` detects conflict. For
        example, always return a conflict error when ``mode`` =
        ``WriteMode.update`` and the given "rev" doesn't match the existing
        file's "rev", even if the existing file has been deleted. This also
        forces a conflict even when the target path refers to a file with
        identical contents.
    """

    __slots__ = [
        "_path_value",
        "_mode_value",
        "_autorename_value",
        "_client_modified_value",
        "_mute_value",
        "_property_groups_value",
        "_strict_conflict_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        path=None,
        mode=None,
        autorename=None,
        client_modified=None,
        mute=None,
        property_groups=None,
        strict_conflict=None,
    ):
        self._path_value = bb.NOT_SET
        self._mode_value = bb.NOT_SET
        self._autorename_value = bb.NOT_SET
        self._client_modified_value = bb.NOT_SET
        self._mute_value = bb.NOT_SET
        self._property_groups_value = bb.NOT_SET
        self._strict_conflict_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if mode is not None:
            self.mode = mode
        if autorename is not None:
            self.autorename = autorename
        if client_modified is not None:
            self.client_modified = client_modified
        if mute is not None:
            self.mute = mute
        if property_groups is not None:
            self.property_groups = property_groups
        if strict_conflict is not None:
            self.strict_conflict = strict_conflict

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: WriteMode (validator is set below)
    mode = bb.Attribute("mode", user_defined=True)

    # Instance attribute type: bool (validator is set below)
    autorename = bb.Attribute("autorename")

    # Instance attribute type: datetime.datetime (validator is set below)
    client_modified = bb.Attribute("client_modified", nullable=True)

    # Instance attribute type: bool (validator is set below)
    mute = bb.Attribute("mute")

    # Instance attribute type: list of [file_properties.PropertyGroup] (validator is set below)
    property_groups = bb.Attribute("property_groups", nullable=True)

    # Instance attribute type: bool (validator is set below)
    strict_conflict = bb.Attribute("strict_conflict")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CommitInfo, self)._process_custom_annotations(annotation_type, field_path, processor)


CommitInfo_validator = bv.Struct(CommitInfo)


class ContentSyncSetting(bb.Struct):
    """
    :ivar ContentSyncSetting.id:
        Id of the item this setting is applied to.
    :ivar ContentSyncSetting.sync_setting:
        Setting for this item.
    """

    __slots__ = [
        "_id_value",
        "_sync_setting_value",
    ]

    _has_required_fields = True

    def __init__(self, id=None, sync_setting=None):
        self._id_value = bb.NOT_SET
        self._sync_setting_value = bb.NOT_SET
        if id is not None:
            self.id = id
        if sync_setting is not None:
            self.sync_setting = sync_setting

    # Instance attribute type: str (validator is set below)
    id = bb.Attribute("id")

    # Instance attribute type: SyncSetting (validator is set below)
    sync_setting = bb.Attribute("sync_setting", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ContentSyncSetting, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ContentSyncSetting_validator = bv.Struct(ContentSyncSetting)


class ContentSyncSettingArg(bb.Struct):
    """
    :ivar ContentSyncSettingArg.id:
        Id of the item this setting is applied to.
    :ivar ContentSyncSettingArg.sync_setting:
        Setting for this item.
    """

    __slots__ = [
        "_id_value",
        "_sync_setting_value",
    ]

    _has_required_fields = True

    def __init__(self, id=None, sync_setting=None):
        self._id_value = bb.NOT_SET
        self._sync_setting_value = bb.NOT_SET
        if id is not None:
            self.id = id
        if sync_setting is not None:
            self.sync_setting = sync_setting

    # Instance attribute type: str (validator is set below)
    id = bb.Attribute("id")

    # Instance attribute type: SyncSettingArg (validator is set below)
    sync_setting = bb.Attribute("sync_setting", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ContentSyncSettingArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ContentSyncSettingArg_validator = bv.Struct(ContentSyncSettingArg)


class CreateFolderArg(bb.Struct):
    """
    :ivar CreateFolderArg.path:
        Path in the user's Dropbox to create.
    :ivar CreateFolderArg.autorename:
        If there's a conflict, have the Dropbox server try to autorename the
        folder to avoid the conflict.
    """

    __slots__ = [
        "_path_value",
        "_autorename_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, autorename=None):
        self._path_value = bb.NOT_SET
        self._autorename_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if autorename is not None:
            self.autorename = autorename

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: bool (validator is set below)
    autorename = bb.Attribute("autorename")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderArg_validator = bv.Struct(CreateFolderArg)


class CreateFolderBatchArg(bb.Struct):
    """
    :ivar CreateFolderBatchArg.paths:
        List of paths to be created in the user's Dropbox. Duplicate path
        arguments in the batch are considered only once.
    :ivar CreateFolderBatchArg.autorename:
        If there's a conflict, have the Dropbox server try to autorename the
        folder to avoid the conflict.
    :ivar CreateFolderBatchArg.force_async:
        Whether to force the create to happen asynchronously.
    """

    __slots__ = [
        "_paths_value",
        "_autorename_value",
        "_force_async_value",
    ]

    _has_required_fields = True

    def __init__(self, paths=None, autorename=None, force_async=None):
        self._paths_value = bb.NOT_SET
        self._autorename_value = bb.NOT_SET
        self._force_async_value = bb.NOT_SET
        if paths is not None:
            self.paths = paths
        if autorename is not None:
            self.autorename = autorename
        if force_async is not None:
            self.force_async = force_async

    # Instance attribute type: list of [str] (validator is set below)
    paths = bb.Attribute("paths")

    # Instance attribute type: bool (validator is set below)
    autorename = bb.Attribute("autorename")

    # Instance attribute type: bool (validator is set below)
    force_async = bb.Attribute("force_async")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderBatchArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderBatchArg_validator = bv.Struct(CreateFolderBatchArg)


class CreateFolderBatchError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar CreateFolderBatchError.too_many_files:
        The operation would involve too many files or folders.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    too_many_files = None
    # Attribute is overwritten below the class definition
    other = None

    def is_too_many_files(self):
        """
        Check if the union tag is ``too_many_files``.

        :rtype: bool
        """
        return self._tag == "too_many_files"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderBatchError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderBatchError_validator = bv.Union(CreateFolderBatchError)


class CreateFolderBatchJobStatus(async_.PollResultBase):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar CreateFolderBatchJobStatus.complete:
        The batch create folder has finished.
    :vartype CreateFolderBatchJobStatus.complete: CreateFolderBatchResult
    :ivar CreateFolderBatchJobStatus.failed:
        The batch create folder has failed.
    :vartype CreateFolderBatchJobStatus.failed: CreateFolderBatchError
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param CreateFolderBatchResult val:
        :rtype: CreateFolderBatchJobStatus
        """
        return cls("complete", val)

    @classmethod
    def failed(cls, val):
        """
        Create an instance of this class set to the ``failed`` tag with value
        ``val``.

        :param CreateFolderBatchError val:
        :rtype: CreateFolderBatchJobStatus
        """
        return cls("failed", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def is_failed(self):
        """
        Check if the union tag is ``failed``.

        :rtype: bool
        """
        return self._tag == "failed"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_complete(self):
        """
        The batch create folder has finished.

        Only call this if :meth:`is_complete` is true.

        :rtype: CreateFolderBatchResult
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def get_failed(self):
        """
        The batch create folder has failed.

        Only call this if :meth:`is_failed` is true.

        :rtype: CreateFolderBatchError
        """
        if not self.is_failed():
            raise AttributeError("tag 'failed' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderBatchJobStatus, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderBatchJobStatus_validator = bv.Union(CreateFolderBatchJobStatus)


class CreateFolderBatchLaunch(async_.LaunchResultBase):
    """
    Result returned by
    :meth:`dropbox.dropbox_client.Dropbox.files_create_folder_batch` that may
    either launch an asynchronous job or complete synchronously.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param CreateFolderBatchResult val:
        :rtype: CreateFolderBatchLaunch
        """
        return cls("complete", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_complete(self):
        """
        Only call this if :meth:`is_complete` is true.

        :rtype: CreateFolderBatchResult
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderBatchLaunch, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderBatchLaunch_validator = bv.Union(CreateFolderBatchLaunch)


class FileOpsResult(bb.Struct):
    """
    Result for File Operations
    """

    __slots__ = []

    _has_required_fields = False

    def __init__(self):
        pass

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FileOpsResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


FileOpsResult_validator = bv.Struct(FileOpsResult)


class CreateFolderBatchResult(FileOpsResult):
    """
    :ivar CreateFolderBatchResult.entries:
        Each entry in ``CreateFolderBatchArg.paths`` will appear at the same
        position inside ``CreateFolderBatchResult.entries``.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        super(CreateFolderBatchResult, self).__init__()
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [CreateFolderBatchResultEntry] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderBatchResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderBatchResult_validator = bv.Struct(CreateFolderBatchResult)


class CreateFolderBatchResultEntry(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = None

    @classmethod
    def success(cls, val):
        """
        Create an instance of this class set to the ``success`` tag with value
        ``val``.

        :param CreateFolderEntryResult val:
        :rtype: CreateFolderBatchResultEntry
        """
        return cls("success", val)

    @classmethod
    def failure(cls, val):
        """
        Create an instance of this class set to the ``failure`` tag with value
        ``val``.

        :param CreateFolderEntryError val:
        :rtype: CreateFolderBatchResultEntry
        """
        return cls("failure", val)

    def is_success(self):
        """
        Check if the union tag is ``success``.

        :rtype: bool
        """
        return self._tag == "success"

    def is_failure(self):
        """
        Check if the union tag is ``failure``.

        :rtype: bool
        """
        return self._tag == "failure"

    def get_success(self):
        """
        Only call this if :meth:`is_success` is true.

        :rtype: CreateFolderEntryResult
        """
        if not self.is_success():
            raise AttributeError("tag 'success' not set")
        return self._value

    def get_failure(self):
        """
        Only call this if :meth:`is_failure` is true.

        :rtype: CreateFolderEntryError
        """
        if not self.is_failure():
            raise AttributeError("tag 'failure' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderBatchResultEntry, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderBatchResultEntry_validator = bv.Union(CreateFolderBatchResultEntry)


class CreateFolderEntryError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param WriteError val:
        :rtype: CreateFolderEntryError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: WriteError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderEntryError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderEntryError_validator = bv.Union(CreateFolderEntryError)


class CreateFolderEntryResult(bb.Struct):
    """
    :ivar CreateFolderEntryResult.metadata:
        Metadata of the created folder.
    """

    __slots__ = [
        "_metadata_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None):
        self._metadata_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata

    # Instance attribute type: FolderMetadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderEntryResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderEntryResult_validator = bv.Struct(CreateFolderEntryResult)


class CreateFolderError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param WriteError val:
        :rtype: CreateFolderError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: WriteError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderError_validator = bv.Union(CreateFolderError)


class CreateFolderResult(FileOpsResult):
    """
    :ivar CreateFolderResult.metadata:
        Metadata of the created folder.
    """

    __slots__ = [
        "_metadata_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None):
        super(CreateFolderResult, self).__init__()
        self._metadata_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata

    # Instance attribute type: FolderMetadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(CreateFolderResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


CreateFolderResult_validator = bv.Struct(CreateFolderResult)


class DeleteArg(bb.Struct):
    """
    :ivar DeleteArg.path:
        Path in the user's Dropbox to delete.
    :ivar DeleteArg.parent_rev:
        Perform delete if given "rev" matches the existing file's latest "rev".
        This field does not support deleting a folder.
    """

    __slots__ = [
        "_path_value",
        "_parent_rev_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, parent_rev=None):
        self._path_value = bb.NOT_SET
        self._parent_rev_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if parent_rev is not None:
            self.parent_rev = parent_rev

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: str (validator is set below)
    parent_rev = bb.Attribute("parent_rev", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeleteArg, self)._process_custom_annotations(annotation_type, field_path, processor)


DeleteArg_validator = bv.Struct(DeleteArg)


class DeleteBatchArg(bb.Struct):
    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [DeleteArg] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeleteBatchArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DeleteBatchArg_validator = bv.Struct(DeleteBatchArg)


class DeleteBatchError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar DeleteBatchError.too_many_write_operations:
        Field is deprecated. Use ``DeleteError.too_many_write_operations``.
        :meth:`dropbox.dropbox_client.Dropbox.files_delete_batch` now provides
        smaller granularity about which entry has failed because of this.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    too_many_write_operations = None
    # Attribute is overwritten below the class definition
    other = None

    def is_too_many_write_operations(self):
        """
        Check if the union tag is ``too_many_write_operations``.

        :rtype: bool
        """
        return self._tag == "too_many_write_operations"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeleteBatchError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DeleteBatchError_validator = bv.Union(DeleteBatchError)


class DeleteBatchJobStatus(async_.PollResultBase):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar DeleteBatchJobStatus.complete:
        The batch delete has finished.
    :vartype DeleteBatchJobStatus.complete: DeleteBatchResult
    :ivar DeleteBatchJobStatus.failed:
        The batch delete has failed.
    :vartype DeleteBatchJobStatus.failed: DeleteBatchError
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param DeleteBatchResult val:
        :rtype: DeleteBatchJobStatus
        """
        return cls("complete", val)

    @classmethod
    def failed(cls, val):
        """
        Create an instance of this class set to the ``failed`` tag with value
        ``val``.

        :param DeleteBatchError val:
        :rtype: DeleteBatchJobStatus
        """
        return cls("failed", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def is_failed(self):
        """
        Check if the union tag is ``failed``.

        :rtype: bool
        """
        return self._tag == "failed"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_complete(self):
        """
        The batch delete has finished.

        Only call this if :meth:`is_complete` is true.

        :rtype: DeleteBatchResult
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def get_failed(self):
        """
        The batch delete has failed.

        Only call this if :meth:`is_failed` is true.

        :rtype: DeleteBatchError
        """
        if not self.is_failed():
            raise AttributeError("tag 'failed' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeleteBatchJobStatus, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DeleteBatchJobStatus_validator = bv.Union(DeleteBatchJobStatus)


class DeleteBatchLaunch(async_.LaunchResultBase):
    """
    Result returned by :meth:`dropbox.dropbox_client.Dropbox.files_delete_batch`
    that may either launch an asynchronous job or complete synchronously.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param DeleteBatchResult val:
        :rtype: DeleteBatchLaunch
        """
        return cls("complete", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_complete(self):
        """
        Only call this if :meth:`is_complete` is true.

        :rtype: DeleteBatchResult
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeleteBatchLaunch, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DeleteBatchLaunch_validator = bv.Union(DeleteBatchLaunch)


class DeleteBatchResult(FileOpsResult):
    """
    :ivar DeleteBatchResult.entries:
        Each entry in ``DeleteBatchArg.entries`` will appear at the same
        position inside ``DeleteBatchResult.entries``.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        super(DeleteBatchResult, self).__init__()
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [DeleteBatchResultEntry] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeleteBatchResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DeleteBatchResult_validator = bv.Struct(DeleteBatchResult)


class DeleteBatchResultData(bb.Struct):
    """
    :ivar DeleteBatchResultData.metadata:
        Metadata of the deleted object.
    """

    __slots__ = [
        "_metadata_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None):
        self._metadata_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata

    # Instance attribute type: Metadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeleteBatchResultData, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DeleteBatchResultData_validator = bv.Struct(DeleteBatchResultData)


class DeleteBatchResultEntry(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = None

    @classmethod
    def success(cls, val):
        """
        Create an instance of this class set to the ``success`` tag with value
        ``val``.

        :param DeleteBatchResultData val:
        :rtype: DeleteBatchResultEntry
        """
        return cls("success", val)

    @classmethod
    def failure(cls, val):
        """
        Create an instance of this class set to the ``failure`` tag with value
        ``val``.

        :param DeleteError val:
        :rtype: DeleteBatchResultEntry
        """
        return cls("failure", val)

    def is_success(self):
        """
        Check if the union tag is ``success``.

        :rtype: bool
        """
        return self._tag == "success"

    def is_failure(self):
        """
        Check if the union tag is ``failure``.

        :rtype: bool
        """
        return self._tag == "failure"

    def get_success(self):
        """
        Only call this if :meth:`is_success` is true.

        :rtype: DeleteBatchResultData
        """
        if not self.is_success():
            raise AttributeError("tag 'success' not set")
        return self._value

    def get_failure(self):
        """
        Only call this if :meth:`is_failure` is true.

        :rtype: DeleteError
        """
        if not self.is_failure():
            raise AttributeError("tag 'failure' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeleteBatchResultEntry, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DeleteBatchResultEntry_validator = bv.Union(DeleteBatchResultEntry)


class DeleteError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar DeleteError.too_many_write_operations:
        There are too many write operations in user's Dropbox. Please retry this
        request.
    :ivar DeleteError.too_many_files:
        There are too many files in one request. Please retry with fewer files.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    too_many_write_operations = None
    # Attribute is overwritten below the class definition
    too_many_files = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path_lookup(cls, val):
        """
        Create an instance of this class set to the ``path_lookup`` tag with
        value ``val``.

        :param LookupError val:
        :rtype: DeleteError
        """
        return cls("path_lookup", val)

    @classmethod
    def path_write(cls, val):
        """
        Create an instance of this class set to the ``path_write`` tag with
        value ``val``.

        :param WriteError val:
        :rtype: DeleteError
        """
        return cls("path_write", val)

    def is_path_lookup(self):
        """
        Check if the union tag is ``path_lookup``.

        :rtype: bool
        """
        return self._tag == "path_lookup"

    def is_path_write(self):
        """
        Check if the union tag is ``path_write``.

        :rtype: bool
        """
        return self._tag == "path_write"

    def is_too_many_write_operations(self):
        """
        Check if the union tag is ``too_many_write_operations``.

        :rtype: bool
        """
        return self._tag == "too_many_write_operations"

    def is_too_many_files(self):
        """
        Check if the union tag is ``too_many_files``.

        :rtype: bool
        """
        return self._tag == "too_many_files"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path_lookup(self):
        """
        Only call this if :meth:`is_path_lookup` is true.

        :rtype: LookupError
        """
        if not self.is_path_lookup():
            raise AttributeError("tag 'path_lookup' not set")
        return self._value

    def get_path_write(self):
        """
        Only call this if :meth:`is_path_write` is true.

        :rtype: WriteError
        """
        if not self.is_path_write():
            raise AttributeError("tag 'path_write' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeleteError, self)._process_custom_annotations(annotation_type, field_path, processor)


DeleteError_validator = bv.Union(DeleteError)


class DeleteResult(FileOpsResult):
    """
    :ivar DeleteResult.metadata:
        Metadata of the deleted object.
    """

    __slots__ = [
        "_metadata_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None):
        super(DeleteResult, self).__init__()
        self._metadata_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata

    # Instance attribute type: Metadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeleteResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DeleteResult_validator = bv.Struct(DeleteResult)


class Metadata(bb.Struct):
    """
    Metadata for a file or folder.

    :ivar Metadata.name:
        The last component of the path (including extension). This never
        contains a slash.
    :ivar Metadata.path_lower:
        The lowercased full path in the user's Dropbox. This always starts with
        a slash. This field will be null if the file or folder is not mounted.
    :ivar Metadata.path_display:
        The cased path to be used for display purposes only. In rare instances
        the casing will not correctly match the user's filesystem, but this
        behavior will match the path provided in the Core API v1, and at least
        the last path component will have the correct casing. Changes to only
        the casing of paths won't be returned by
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder_continue`. This
        field will be null if the file or folder is not mounted.
    :ivar Metadata.parent_shared_folder_id:
        Field is deprecated. Please use
        ``FileSharingInfo.parent_shared_folder_id`` or
        ``FolderSharingInfo.parent_shared_folder_id`` instead.
    :ivar Metadata.preview_url:
        The preview URL of the file.
    """

    __slots__ = [
        "_name_value",
        "_path_lower_value",
        "_path_display_value",
        "_parent_shared_folder_id_value",
        "_preview_url_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        name=None,
        path_lower=None,
        path_display=None,
        parent_shared_folder_id=None,
        preview_url=None,
    ):
        self._name_value = bb.NOT_SET
        self._path_lower_value = bb.NOT_SET
        self._path_display_value = bb.NOT_SET
        self._parent_shared_folder_id_value = bb.NOT_SET
        self._preview_url_value = bb.NOT_SET
        if name is not None:
            self.name = name
        if path_lower is not None:
            self.path_lower = path_lower
        if path_display is not None:
            self.path_display = path_display
        if parent_shared_folder_id is not None:
            self.parent_shared_folder_id = parent_shared_folder_id
        if preview_url is not None:
            self.preview_url = preview_url

    # Instance attribute type: str (validator is set below)
    name = bb.Attribute("name")

    # Instance attribute type: str (validator is set below)
    path_lower = bb.Attribute("path_lower", nullable=True)

    # Instance attribute type: str (validator is set below)
    path_display = bb.Attribute("path_display", nullable=True)

    # Instance attribute type: str (validator is set below)
    parent_shared_folder_id = bb.Attribute("parent_shared_folder_id", nullable=True)

    # Instance attribute type: str (validator is set below)
    preview_url = bb.Attribute("preview_url", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(Metadata, self)._process_custom_annotations(annotation_type, field_path, processor)


Metadata_validator = bv.StructTree(Metadata)


class DeletedMetadata(Metadata):
    """
    Indicates that there used to be a file or folder at this path, but it no
    longer exists.

    :ivar DeletedMetadata.is_restorable:
        If present, indicates whether this deleted entry can be restored.
    """

    __slots__ = [
        "_is_restorable_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        name=None,
        path_lower=None,
        path_display=None,
        parent_shared_folder_id=None,
        preview_url=None,
        is_restorable=None,
    ):
        super(DeletedMetadata, self).__init__(
            name, path_lower, path_display, parent_shared_folder_id, preview_url
        )
        self._is_restorable_value = bb.NOT_SET
        if is_restorable is not None:
            self.is_restorable = is_restorable

    # Instance attribute type: bool (validator is set below)
    is_restorable = bb.Attribute("is_restorable", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DeletedMetadata, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DeletedMetadata_validator = bv.Struct(DeletedMetadata)


class Dimensions(bb.Struct):
    """
    Dimensions for a photo or video.

    :ivar Dimensions.height:
        Height of the photo/video.
    :ivar Dimensions.width:
        Width of the photo/video.
    """

    __slots__ = [
        "_height_value",
        "_width_value",
    ]

    _has_required_fields = True

    def __init__(self, height=None, width=None):
        self._height_value = bb.NOT_SET
        self._width_value = bb.NOT_SET
        if height is not None:
            self.height = height
        if width is not None:
            self.width = width

    # Instance attribute type: int (validator is set below)
    height = bb.Attribute("height")

    # Instance attribute type: int (validator is set below)
    width = bb.Attribute("width")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(Dimensions, self)._process_custom_annotations(annotation_type, field_path, processor)


Dimensions_validator = bv.Struct(Dimensions)


class DownloadArg(bb.Struct):
    """
    :ivar DownloadArg.path:
        The path of the file to download.
    :ivar DownloadArg.rev:
        Field is deprecated. Please specify revision in ``path`` instead.
    """

    __slots__ = [
        "_path_value",
        "_rev_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, rev=None):
        self._path_value = bb.NOT_SET
        self._rev_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if rev is not None:
            self.rev = rev

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: str (validator is set below)
    rev = bb.Attribute("rev", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DownloadArg, self)._process_custom_annotations(annotation_type, field_path, processor)


DownloadArg_validator = bv.Struct(DownloadArg)


class DownloadError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar DownloadError.unsupported_file:
        This file type cannot be downloaded directly; use
        :meth:`dropbox.dropbox_client.Dropbox.files_export` instead.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    unsupported_file = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: DownloadError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_unsupported_file(self):
        """
        Check if the union tag is ``unsupported_file``.

        :rtype: bool
        """
        return self._tag == "unsupported_file"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DownloadError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DownloadError_validator = bv.Union(DownloadError)


class DownloadZipArg(bb.Struct):
    """
    :ivar DownloadZipArg.path:
        The path of the folder to download.
    """

    __slots__ = [
        "_path_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None):
        self._path_value = bb.NOT_SET
        if path is not None:
            self.path = path

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DownloadZipArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DownloadZipArg_validator = bv.Struct(DownloadZipArg)


class DownloadZipError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar DownloadZipError.too_large:
        The folder or a file is too large to download.
    :ivar DownloadZipError.too_many_files:
        The folder has too many files to download.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    too_large = None
    # Attribute is overwritten below the class definition
    too_many_files = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: DownloadZipError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_too_large(self):
        """
        Check if the union tag is ``too_large``.

        :rtype: bool
        """
        return self._tag == "too_large"

    def is_too_many_files(self):
        """
        Check if the union tag is ``too_many_files``.

        :rtype: bool
        """
        return self._tag == "too_many_files"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DownloadZipError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DownloadZipError_validator = bv.Union(DownloadZipError)


class DownloadZipResult(bb.Struct):
    __slots__ = [
        "_metadata_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None):
        self._metadata_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata

    # Instance attribute type: FolderMetadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(DownloadZipResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


DownloadZipResult_validator = bv.Struct(DownloadZipResult)


class ExportArg(bb.Struct):
    """
    :ivar ExportArg.path:
        The path of the file to be exported.
    :ivar ExportArg.export_format:
        The file format to which the file should be exported. This must be one
        of the formats listed in the file's export_options returned by
        :meth:`dropbox.dropbox_client.Dropbox.files_get_metadata`. If none is
        specified, the default format (specified in export_as in file metadata)
        will be used.
    """

    __slots__ = [
        "_path_value",
        "_export_format_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, export_format=None):
        self._path_value = bb.NOT_SET
        self._export_format_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if export_format is not None:
            self.export_format = export_format

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: str (validator is set below)
    export_format = bb.Attribute("export_format", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ExportArg, self)._process_custom_annotations(annotation_type, field_path, processor)


ExportArg_validator = bv.Struct(ExportArg)


class ExportError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ExportError.non_exportable:
        This file type cannot be exported. Use
        :meth:`dropbox.dropbox_client.Dropbox.files_download` instead.
    :ivar ExportError.invalid_export_format:
        The specified export format is not a valid option for this file type.
    :ivar ExportError.retry_error:
        The exportable content is not yet available. Please retry later.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    non_exportable = None
    # Attribute is overwritten below the class definition
    invalid_export_format = None
    # Attribute is overwritten below the class definition
    retry_error = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: ExportError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_non_exportable(self):
        """
        Check if the union tag is ``non_exportable``.

        :rtype: bool
        """
        return self._tag == "non_exportable"

    def is_invalid_export_format(self):
        """
        Check if the union tag is ``invalid_export_format``.

        :rtype: bool
        """
        return self._tag == "invalid_export_format"

    def is_retry_error(self):
        """
        Check if the union tag is ``retry_error``.

        :rtype: bool
        """
        return self._tag == "retry_error"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ExportError, self)._process_custom_annotations(annotation_type, field_path, processor)


ExportError_validator = bv.Union(ExportError)


class ExportInfo(bb.Struct):
    """
    Export information for a file.

    :ivar ExportInfo.export_as:
        Format to which the file can be exported to.
    :ivar ExportInfo.export_options:
        Additional formats to which the file can be exported. These values can
        be specified as the export_format in /files/export.
    """

    __slots__ = [
        "_export_as_value",
        "_export_options_value",
    ]

    _has_required_fields = False

    def __init__(self, export_as=None, export_options=None):
        self._export_as_value = bb.NOT_SET
        self._export_options_value = bb.NOT_SET
        if export_as is not None:
            self.export_as = export_as
        if export_options is not None:
            self.export_options = export_options

    # Instance attribute type: str (validator is set below)
    export_as = bb.Attribute("export_as", nullable=True)

    # Instance attribute type: list of [str] (validator is set below)
    export_options = bb.Attribute("export_options", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ExportInfo, self)._process_custom_annotations(annotation_type, field_path, processor)


ExportInfo_validator = bv.Struct(ExportInfo)


class ExportMetadata(bb.Struct):
    """
    :ivar ExportMetadata.name:
        The last component of the path (including extension). This never
        contains a slash.
    :ivar ExportMetadata.size:
        The file size in bytes.
    :ivar ExportMetadata.export_hash:
        A hash based on the exported file content. This field can be used to
        verify data integrity. Similar to content hash. For more information see
        our `Content hash
        <https://www.dropbox.com/developers/reference/content-hash>`_ page.
    :ivar ExportMetadata.paper_revision:
        If the file is a Paper doc, this gives the latest doc revision which can
        be used in :meth:`dropbox.dropbox_client.Dropbox.files_paper_update`.
    """

    __slots__ = [
        "_name_value",
        "_size_value",
        "_export_hash_value",
        "_paper_revision_value",
    ]

    _has_required_fields = True

    def __init__(self, name=None, size=None, export_hash=None, paper_revision=None):
        self._name_value = bb.NOT_SET
        self._size_value = bb.NOT_SET
        self._export_hash_value = bb.NOT_SET
        self._paper_revision_value = bb.NOT_SET
        if name is not None:
            self.name = name
        if size is not None:
            self.size = size
        if export_hash is not None:
            self.export_hash = export_hash
        if paper_revision is not None:
            self.paper_revision = paper_revision

    # Instance attribute type: str (validator is set below)
    name = bb.Attribute("name")

    # Instance attribute type: int (validator is set below)
    size = bb.Attribute("size")

    # Instance attribute type: str (validator is set below)
    export_hash = bb.Attribute("export_hash", nullable=True)

    # Instance attribute type: int (validator is set below)
    paper_revision = bb.Attribute("paper_revision", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ExportMetadata, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ExportMetadata_validator = bv.Struct(ExportMetadata)


class ExportResult(bb.Struct):
    """
    :ivar ExportResult.export_metadata:
        Metadata for the exported version of the file.
    :ivar ExportResult.file_metadata:
        Metadata for the original file.
    """

    __slots__ = [
        "_export_metadata_value",
        "_file_metadata_value",
    ]

    _has_required_fields = True

    def __init__(self, export_metadata=None, file_metadata=None):
        self._export_metadata_value = bb.NOT_SET
        self._file_metadata_value = bb.NOT_SET
        if export_metadata is not None:
            self.export_metadata = export_metadata
        if file_metadata is not None:
            self.file_metadata = file_metadata

    # Instance attribute type: ExportMetadata (validator is set below)
    export_metadata = bb.Attribute("export_metadata", user_defined=True)

    # Instance attribute type: FileMetadata (validator is set below)
    file_metadata = bb.Attribute("file_metadata", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ExportResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ExportResult_validator = bv.Struct(ExportResult)


class FileCategory(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar FileCategory.image:
        jpg, png, gif, and more.
    :ivar FileCategory.document:
        doc, docx, txt, and more.
    :ivar FileCategory.pdf:
        pdf.
    :ivar FileCategory.spreadsheet:
        xlsx, xls, csv, and more.
    :ivar FileCategory.presentation:
        ppt, pptx, key, and more.
    :ivar FileCategory.audio:
        mp3, wav, mid, and more.
    :ivar FileCategory.video:
        mov, wmv, mp4, and more.
    :ivar FileCategory.folder:
        dropbox folder.
    :ivar FileCategory.paper:
        dropbox paper doc.
    :ivar FileCategory.others:
        any file not in one of the categories above.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    image = None
    # Attribute is overwritten below the class definition
    document = None
    # Attribute is overwritten below the class definition
    pdf = None
    # Attribute is overwritten below the class definition
    spreadsheet = None
    # Attribute is overwritten below the class definition
    presentation = None
    # Attribute is overwritten below the class definition
    audio = None
    # Attribute is overwritten below the class definition
    video = None
    # Attribute is overwritten below the class definition
    folder = None
    # Attribute is overwritten below the class definition
    paper = None
    # Attribute is overwritten below the class definition
    others = None
    # Attribute is overwritten below the class definition
    other = None

    def is_image(self):
        """
        Check if the union tag is ``image``.

        :rtype: bool
        """
        return self._tag == "image"

    def is_document(self):
        """
        Check if the union tag is ``document``.

        :rtype: bool
        """
        return self._tag == "document"

    def is_pdf(self):
        """
        Check if the union tag is ``pdf``.

        :rtype: bool
        """
        return self._tag == "pdf"

    def is_spreadsheet(self):
        """
        Check if the union tag is ``spreadsheet``.

        :rtype: bool
        """
        return self._tag == "spreadsheet"

    def is_presentation(self):
        """
        Check if the union tag is ``presentation``.

        :rtype: bool
        """
        return self._tag == "presentation"

    def is_audio(self):
        """
        Check if the union tag is ``audio``.

        :rtype: bool
        """
        return self._tag == "audio"

    def is_video(self):
        """
        Check if the union tag is ``video``.

        :rtype: bool
        """
        return self._tag == "video"

    def is_folder(self):
        """
        Check if the union tag is ``folder``.

        :rtype: bool
        """
        return self._tag == "folder"

    def is_paper(self):
        """
        Check if the union tag is ``paper``.

        :rtype: bool
        """
        return self._tag == "paper"

    def is_others(self):
        """
        Check if the union tag is ``others``.

        :rtype: bool
        """
        return self._tag == "others"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FileCategory, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


FileCategory_validator = bv.Union(FileCategory)


class FileLock(bb.Struct):
    """
    :ivar FileLock.content:
        The lock description.
    """

    __slots__ = [
        "_content_value",
    ]

    _has_required_fields = True

    def __init__(self, content=None):
        self._content_value = bb.NOT_SET
        if content is not None:
            self.content = content

    # Instance attribute type: FileLockContent (validator is set below)
    content = bb.Attribute("content", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FileLock, self)._process_custom_annotations(annotation_type, field_path, processor)


FileLock_validator = bv.Struct(FileLock)


class FileLockContent(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar FileLockContent.unlocked:
        Empty type to indicate no lock.
    :ivar FileLockContent.single_user:
        A lock held by a single user.
    :vartype FileLockContent.single_user: SingleUserLock
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    unlocked = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def single_user(cls, val):
        """
        Create an instance of this class set to the ``single_user`` tag with
        value ``val``.

        :param SingleUserLock val:
        :rtype: FileLockContent
        """
        return cls("single_user", val)

    def is_unlocked(self):
        """
        Check if the union tag is ``unlocked``.

        :rtype: bool
        """
        return self._tag == "unlocked"

    def is_single_user(self):
        """
        Check if the union tag is ``single_user``.

        :rtype: bool
        """
        return self._tag == "single_user"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_single_user(self):
        """
        A lock held by a single user.

        Only call this if :meth:`is_single_user` is true.

        :rtype: SingleUserLock
        """
        if not self.is_single_user():
            raise AttributeError("tag 'single_user' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FileLockContent, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


FileLockContent_validator = bv.Union(FileLockContent)


class FileLockMetadata(bb.Struct):
    """
    :ivar FileLockMetadata.is_lockholder:
        True if caller holds the file lock.
    :ivar FileLockMetadata.lockholder_name:
        The display name of the lock holder.
    :ivar FileLockMetadata.lockholder_account_id:
        The account ID of the lock holder if known.
    :ivar FileLockMetadata.created:
        The timestamp of the lock was created.
    """

    __slots__ = [
        "_is_lockholder_value",
        "_lockholder_name_value",
        "_lockholder_account_id_value",
        "_created_value",
    ]

    _has_required_fields = False

    def __init__(
        self,
        is_lockholder=None,
        lockholder_name=None,
        lockholder_account_id=None,
        created=None,
    ):
        self._is_lockholder_value = bb.NOT_SET
        self._lockholder_name_value = bb.NOT_SET
        self._lockholder_account_id_value = bb.NOT_SET
        self._created_value = bb.NOT_SET
        if is_lockholder is not None:
            self.is_lockholder = is_lockholder
        if lockholder_name is not None:
            self.lockholder_name = lockholder_name
        if lockholder_account_id is not None:
            self.lockholder_account_id = lockholder_account_id
        if created is not None:
            self.created = created

    # Instance attribute type: bool (validator is set below)
    is_lockholder = bb.Attribute("is_lockholder", nullable=True)

    # Instance attribute type: str (validator is set below)
    lockholder_name = bb.Attribute("lockholder_name", nullable=True)

    # Instance attribute type: str (validator is set below)
    lockholder_account_id = bb.Attribute("lockholder_account_id", nullable=True)

    # Instance attribute type: datetime.datetime (validator is set below)
    created = bb.Attribute("created", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FileLockMetadata, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


FileLockMetadata_validator = bv.Struct(FileLockMetadata)


class FileMetadata(Metadata):
    """
    :ivar FileMetadata.id:
        A unique identifier for the file.
    :ivar FileMetadata.client_modified:
        For files, this is the modification time set by the desktop client when
        the file was added to Dropbox. Since this time is not verified (the
        Dropbox server stores whatever the desktop client sends up), this should
        only be used for display purposes (such as sorting) and not, for
        example, to determine if a file has changed or not.
    :ivar FileMetadata.server_modified:
        The last time the file was modified on Dropbox.
    :ivar FileMetadata.rev:
        A unique identifier for the current revision of a file. This field is
        the same rev as elsewhere in the API and can be used to detect changes
        and avoid conflicts.
    :ivar FileMetadata.size:
        The file size in bytes.
    :ivar FileMetadata.media_info:
        Additional information if the file is a photo or video. This field will
        not be set on entries returned by
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder`,
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder_continue`, or
        :meth:`dropbox.dropbox_client.Dropbox.files_get_thumbnail_batch`,
        starting December 2, 2019.
    :ivar FileMetadata.symlink_info:
        Set if this file is a symlink.
    :ivar FileMetadata.sharing_info:
        Set if this file is contained in a shared folder.
    :ivar FileMetadata.is_downloadable:
        If true, file can be downloaded directly; else the file must be
        exported.
    :ivar FileMetadata.export_info:
        Information about format this file can be exported to. This filed must
        be set if ``is_downloadable`` is set to false.
    :ivar FileMetadata.property_groups:
        Additional information if the file has custom properties with the
        property template specified.
    :ivar FileMetadata.has_explicit_shared_members:
        This flag will only be present if include_has_explicit_shared_members is
        true in :meth:`dropbox.dropbox_client.Dropbox.files_list_folder` or
        :meth:`dropbox.dropbox_client.Dropbox.files_get_metadata`. If this flag
        is present, it will be true if this file has any explicit shared
        members. This is different from sharing_info in that this could be true
        in the case where a file has explicit members but is not contained
        within a shared folder.
    :ivar FileMetadata.content_hash:
        A hash of the file content. This field can be used to verify data
        integrity. For more information see our `Content hash
        <https://www.dropbox.com/developers/reference/content-hash>`_ page.
    :ivar FileMetadata.file_lock_info:
        If present, the metadata associated with the file's current lock.
    :ivar FileMetadata.is_restorable:
        If present, indicates whether this file revision can be restored.
    """

    __slots__ = [
        "_id_value",
        "_client_modified_value",
        "_server_modified_value",
        "_rev_value",
        "_size_value",
        "_media_info_value",
        "_symlink_info_value",
        "_sharing_info_value",
        "_is_downloadable_value",
        "_export_info_value",
        "_property_groups_value",
        "_has_explicit_shared_members_value",
        "_content_hash_value",
        "_file_lock_info_value",
        "_is_restorable_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        name=None,
        id=None,
        client_modified=None,
        server_modified=None,
        rev=None,
        size=None,
        path_lower=None,
        path_display=None,
        parent_shared_folder_id=None,
        preview_url=None,
        media_info=None,
        symlink_info=None,
        sharing_info=None,
        is_downloadable=None,
        export_info=None,
        property_groups=None,
        has_explicit_shared_members=None,
        content_hash=None,
        file_lock_info=None,
        is_restorable=None,
    ):
        super(FileMetadata, self).__init__(
            name, path_lower, path_display, parent_shared_folder_id, preview_url
        )
        self._id_value = bb.NOT_SET
        self._client_modified_value = bb.NOT_SET
        self._server_modified_value = bb.NOT_SET
        self._rev_value = bb.NOT_SET
        self._size_value = bb.NOT_SET
        self._media_info_value = bb.NOT_SET
        self._symlink_info_value = bb.NOT_SET
        self._sharing_info_value = bb.NOT_SET
        self._is_downloadable_value = bb.NOT_SET
        self._export_info_value = bb.NOT_SET
        self._property_groups_value = bb.NOT_SET
        self._has_explicit_shared_members_value = bb.NOT_SET
        self._content_hash_value = bb.NOT_SET
        self._file_lock_info_value = bb.NOT_SET
        self._is_restorable_value = bb.NOT_SET
        if id is not None:
            self.id = id
        if client_modified is not None:
            self.client_modified = client_modified
        if server_modified is not None:
            self.server_modified = server_modified
        if rev is not None:
            self.rev = rev
        if size is not None:
            self.size = size
        if media_info is not None:
            self.media_info = media_info
        if symlink_info is not None:
            self.symlink_info = symlink_info
        if sharing_info is not None:
            self.sharing_info = sharing_info
        if is_downloadable is not None:
            self.is_downloadable = is_downloadable
        if export_info is not None:
            self.export_info = export_info
        if property_groups is not None:
            self.property_groups = property_groups
        if has_explicit_shared_members is not None:
            self.has_explicit_shared_members = has_explicit_shared_members
        if content_hash is not None:
            self.content_hash = content_hash
        if file_lock_info is not None:
            self.file_lock_info = file_lock_info
        if is_restorable is not None:
            self.is_restorable = is_restorable

    # Instance attribute type: str (validator is set below)
    id = bb.Attribute("id")

    # Instance attribute type: datetime.datetime (validator is set below)
    client_modified = bb.Attribute("client_modified")

    # Instance attribute type: datetime.datetime (validator is set below)
    server_modified = bb.Attribute("server_modified")

    # Instance attribute type: str (validator is set below)
    rev = bb.Attribute("rev")

    # Instance attribute type: int (validator is set below)
    size = bb.Attribute("size")

    # Instance attribute type: MediaInfo (validator is set below)
    media_info = bb.Attribute("media_info", nullable=True, user_defined=True)

    # Instance attribute type: SymlinkInfo (validator is set below)
    symlink_info = bb.Attribute("symlink_info", nullable=True, user_defined=True)

    # Instance attribute type: FileSharingInfo (validator is set below)
    sharing_info = bb.Attribute("sharing_info", nullable=True, user_defined=True)

    # Instance attribute type: bool (validator is set below)
    is_downloadable = bb.Attribute("is_downloadable")

    # Instance attribute type: ExportInfo (validator is set below)
    export_info = bb.Attribute("export_info", nullable=True, user_defined=True)

    # Instance attribute type: list of [file_properties.PropertyGroup] (validator is set below)
    property_groups = bb.Attribute("property_groups", nullable=True)

    # Instance attribute type: bool (validator is set below)
    has_explicit_shared_members = bb.Attribute("has_explicit_shared_members", nullable=True)

    # Instance attribute type: str (validator is set below)
    content_hash = bb.Attribute("content_hash", nullable=True)

    # Instance attribute type: FileLockMetadata (validator is set below)
    file_lock_info = bb.Attribute("file_lock_info", nullable=True, user_defined=True)

    # Instance attribute type: bool (validator is set below)
    is_restorable = bb.Attribute("is_restorable", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FileMetadata, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


FileMetadata_validator = bv.Struct(FileMetadata)


class SharingInfo(bb.Struct):
    """
    Sharing info for a file or folder.

    :ivar SharingInfo.read_only:
        True if the file or folder is inside a read-only shared folder.
    """

    __slots__ = [
        "_read_only_value",
    ]

    _has_required_fields = True

    def __init__(self, read_only=None):
        self._read_only_value = bb.NOT_SET
        if read_only is not None:
            self.read_only = read_only

    # Instance attribute type: bool (validator is set below)
    read_only = bb.Attribute("read_only")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SharingInfo, self)._process_custom_annotations(annotation_type, field_path, processor)


SharingInfo_validator = bv.Struct(SharingInfo)


class FileSharingInfo(SharingInfo):
    """
    Sharing info for a file which is contained by a shared folder.

    :ivar FileSharingInfo.parent_shared_folder_id:
        ID of shared folder that holds this file.
    :ivar FileSharingInfo.modified_by:
        The last user who modified the file. This field will be null if the
        user's account has been deleted.
    """

    __slots__ = [
        "_parent_shared_folder_id_value",
        "_modified_by_value",
    ]

    _has_required_fields = True

    def __init__(self, read_only=None, parent_shared_folder_id=None, modified_by=None):
        super(FileSharingInfo, self).__init__(read_only)
        self._parent_shared_folder_id_value = bb.NOT_SET
        self._modified_by_value = bb.NOT_SET
        if parent_shared_folder_id is not None:
            self.parent_shared_folder_id = parent_shared_folder_id
        if modified_by is not None:
            self.modified_by = modified_by

    # Instance attribute type: str (validator is set below)
    parent_shared_folder_id = bb.Attribute("parent_shared_folder_id")

    # Instance attribute type: str (validator is set below)
    modified_by = bb.Attribute("modified_by", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FileSharingInfo, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


FileSharingInfo_validator = bv.Struct(FileSharingInfo)


class FileStatus(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    active = None
    # Attribute is overwritten below the class definition
    deleted = None
    # Attribute is overwritten below the class definition
    other = None

    def is_active(self):
        """
        Check if the union tag is ``active``.

        :rtype: bool
        """
        return self._tag == "active"

    def is_deleted(self):
        """
        Check if the union tag is ``deleted``.

        :rtype: bool
        """
        return self._tag == "deleted"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FileStatus, self)._process_custom_annotations(annotation_type, field_path, processor)


FileStatus_validator = bv.Union(FileStatus)


class FolderMetadata(Metadata):
    """
    :ivar FolderMetadata.id:
        A unique identifier for the folder.
    :ivar FolderMetadata.shared_folder_id:
        Field is deprecated. Please use ``sharing_info`` instead.
    :ivar FolderMetadata.sharing_info:
        Set if the folder is contained in a shared folder or is a shared folder
        mount point.
    :ivar FolderMetadata.property_groups:
        Additional information if the file has custom properties with the
        property template specified. Note that only properties associated with
        user-owned templates, not team-owned templates, can be attached to
        folders.
    """

    __slots__ = [
        "_id_value",
        "_shared_folder_id_value",
        "_sharing_info_value",
        "_property_groups_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        name=None,
        id=None,
        path_lower=None,
        path_display=None,
        parent_shared_folder_id=None,
        preview_url=None,
        shared_folder_id=None,
        sharing_info=None,
        property_groups=None,
    ):
        super(FolderMetadata, self).__init__(
            name, path_lower, path_display, parent_shared_folder_id, preview_url
        )
        self._id_value = bb.NOT_SET
        self._shared_folder_id_value = bb.NOT_SET
        self._sharing_info_value = bb.NOT_SET
        self._property_groups_value = bb.NOT_SET
        if id is not None:
            self.id = id
        if shared_folder_id is not None:
            self.shared_folder_id = shared_folder_id
        if sharing_info is not None:
            self.sharing_info = sharing_info
        if property_groups is not None:
            self.property_groups = property_groups

    # Instance attribute type: str (validator is set below)
    id = bb.Attribute("id")

    # Instance attribute type: str (validator is set below)
    shared_folder_id = bb.Attribute("shared_folder_id", nullable=True)

    # Instance attribute type: FolderSharingInfo (validator is set below)
    sharing_info = bb.Attribute("sharing_info", nullable=True, user_defined=True)

    # Instance attribute type: list of [file_properties.PropertyGroup] (validator is set below)
    property_groups = bb.Attribute("property_groups", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FolderMetadata, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


FolderMetadata_validator = bv.Struct(FolderMetadata)


class FolderSharingInfo(SharingInfo):
    """
    Sharing info for a folder which is contained in a shared folder or is a
    shared folder mount point.

    :ivar FolderSharingInfo.parent_shared_folder_id:
        Set if the folder is contained by a shared folder.
    :ivar FolderSharingInfo.shared_folder_id:
        If this folder is a shared folder mount point, the ID of the shared
        folder mounted at this location.
    :ivar FolderSharingInfo.traverse_only:
        Specifies that the folder can only be traversed and the user can only
        see a limited subset of the contents of this folder because they don't
        have read access to this folder. They do, however, have access to some
        sub folder.
    :ivar FolderSharingInfo.no_access:
        Specifies that the folder cannot be accessed by the user.
    """

    __slots__ = [
        "_parent_shared_folder_id_value",
        "_shared_folder_id_value",
        "_traverse_only_value",
        "_no_access_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        read_only=None,
        parent_shared_folder_id=None,
        shared_folder_id=None,
        traverse_only=None,
        no_access=None,
    ):
        super(FolderSharingInfo, self).__init__(read_only)
        self._parent_shared_folder_id_value = bb.NOT_SET
        self._shared_folder_id_value = bb.NOT_SET
        self._traverse_only_value = bb.NOT_SET
        self._no_access_value = bb.NOT_SET
        if parent_shared_folder_id is not None:
            self.parent_shared_folder_id = parent_shared_folder_id
        if shared_folder_id is not None:
            self.shared_folder_id = shared_folder_id
        if traverse_only is not None:
            self.traverse_only = traverse_only
        if no_access is not None:
            self.no_access = no_access

    # Instance attribute type: str (validator is set below)
    parent_shared_folder_id = bb.Attribute("parent_shared_folder_id", nullable=True)

    # Instance attribute type: str (validator is set below)
    shared_folder_id = bb.Attribute("shared_folder_id", nullable=True)

    # Instance attribute type: bool (validator is set below)
    traverse_only = bb.Attribute("traverse_only")

    # Instance attribute type: bool (validator is set below)
    no_access = bb.Attribute("no_access")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FolderSharingInfo, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


FolderSharingInfo_validator = bv.Struct(FolderSharingInfo)


class GetCopyReferenceArg(bb.Struct):
    """
    :ivar GetCopyReferenceArg.path:
        The path to the file or folder you want to get a copy reference to.
    """

    __slots__ = [
        "_path_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None):
        self._path_value = bb.NOT_SET
        if path is not None:
            self.path = path

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetCopyReferenceArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetCopyReferenceArg_validator = bv.Struct(GetCopyReferenceArg)


class GetCopyReferenceError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: GetCopyReferenceError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetCopyReferenceError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetCopyReferenceError_validator = bv.Union(GetCopyReferenceError)


class GetCopyReferenceResult(bb.Struct):
    """
    :ivar GetCopyReferenceResult.metadata:
        Metadata of the file or folder.
    :ivar GetCopyReferenceResult.copy_reference:
        A copy reference to the file or folder.
    :ivar GetCopyReferenceResult.expires:
        The expiration date of the copy reference. This value is currently set
        to be far enough in the future so that expiration is effectively not an
        issue.
    """

    __slots__ = [
        "_metadata_value",
        "_copy_reference_value",
        "_expires_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None, copy_reference=None, expires=None):
        self._metadata_value = bb.NOT_SET
        self._copy_reference_value = bb.NOT_SET
        self._expires_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata
        if copy_reference is not None:
            self.copy_reference = copy_reference
        if expires is not None:
            self.expires = expires

    # Instance attribute type: Metadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    # Instance attribute type: str (validator is set below)
    copy_reference = bb.Attribute("copy_reference")

    # Instance attribute type: datetime.datetime (validator is set below)
    expires = bb.Attribute("expires")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetCopyReferenceResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetCopyReferenceResult_validator = bv.Struct(GetCopyReferenceResult)


class GetTagsArg(bb.Struct):
    """
    :ivar GetTagsArg.paths:
        Path to the items.
    """

    __slots__ = [
        "_paths_value",
    ]

    _has_required_fields = True

    def __init__(self, paths=None):
        self._paths_value = bb.NOT_SET
        if paths is not None:
            self.paths = paths

    # Instance attribute type: list of [str] (validator is set below)
    paths = bb.Attribute("paths")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetTagsArg, self)._process_custom_annotations(annotation_type, field_path, processor)


GetTagsArg_validator = bv.Struct(GetTagsArg)


class GetTagsResult(bb.Struct):
    """
    :ivar GetTagsResult.paths_to_tags:
        List of paths and their corresponding tags.
    """

    __slots__ = [
        "_paths_to_tags_value",
    ]

    _has_required_fields = True

    def __init__(self, paths_to_tags=None):
        self._paths_to_tags_value = bb.NOT_SET
        if paths_to_tags is not None:
            self.paths_to_tags = paths_to_tags

    # Instance attribute type: list of [PathToTags] (validator is set below)
    paths_to_tags = bb.Attribute("paths_to_tags")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetTagsResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetTagsResult_validator = bv.Struct(GetTagsResult)


class GetTemporaryLinkArg(bb.Struct):
    """
    :ivar GetTemporaryLinkArg.path:
        The path to the file you want a temporary link to.
    """

    __slots__ = [
        "_path_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None):
        self._path_value = bb.NOT_SET
        if path is not None:
            self.path = path

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetTemporaryLinkArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetTemporaryLinkArg_validator = bv.Struct(GetTemporaryLinkArg)


class GetTemporaryLinkError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar GetTemporaryLinkError.email_not_verified:
        This user's email address is not verified. This functionality is only
        available on accounts with a verified email address. Users can verify
        their email address `here <https://www.dropbox.com/help/317>`_.
    :ivar GetTemporaryLinkError.unsupported_file:
        Cannot get temporary link to this file type; use
        :meth:`dropbox.dropbox_client.Dropbox.files_export` instead.
    :ivar GetTemporaryLinkError.not_allowed:
        The user is not allowed to request a temporary link to the specified
        file. For example, this can occur if the file is restricted or if the
        user's links are `banned
        <https://help.dropbox.com/files-folders/share/banned-links>`_.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    email_not_verified = None
    # Attribute is overwritten below the class definition
    unsupported_file = None
    # Attribute is overwritten below the class definition
    not_allowed = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: GetTemporaryLinkError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_email_not_verified(self):
        """
        Check if the union tag is ``email_not_verified``.

        :rtype: bool
        """
        return self._tag == "email_not_verified"

    def is_unsupported_file(self):
        """
        Check if the union tag is ``unsupported_file``.

        :rtype: bool
        """
        return self._tag == "unsupported_file"

    def is_not_allowed(self):
        """
        Check if the union tag is ``not_allowed``.

        :rtype: bool
        """
        return self._tag == "not_allowed"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetTemporaryLinkError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetTemporaryLinkError_validator = bv.Union(GetTemporaryLinkError)


class GetTemporaryLinkResult(bb.Struct):
    """
    :ivar GetTemporaryLinkResult.metadata:
        Metadata of the file.
    :ivar GetTemporaryLinkResult.link:
        The temporary link which can be used to stream content the file.
    """

    __slots__ = [
        "_metadata_value",
        "_link_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None, link=None):
        self._metadata_value = bb.NOT_SET
        self._link_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata
        if link is not None:
            self.link = link

    # Instance attribute type: FileMetadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    # Instance attribute type: str (validator is set below)
    link = bb.Attribute("link")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetTemporaryLinkResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetTemporaryLinkResult_validator = bv.Struct(GetTemporaryLinkResult)


class GetTemporaryUploadLinkArg(bb.Struct):
    """
    :ivar GetTemporaryUploadLinkArg.commit_info:
        Contains the path and other optional modifiers for the future upload
        commit. Equivalent to the parameters provided to
        :meth:`dropbox.dropbox_client.Dropbox.files_upload`.
    :ivar GetTemporaryUploadLinkArg.duration:
        How long before this link expires, in seconds. Attempting to start an
        upload with this link longer than this period of time after link
        creation will result in an error.
    """

    __slots__ = [
        "_commit_info_value",
        "_duration_value",
    ]

    _has_required_fields = True

    def __init__(self, commit_info=None, duration=None):
        self._commit_info_value = bb.NOT_SET
        self._duration_value = bb.NOT_SET
        if commit_info is not None:
            self.commit_info = commit_info
        if duration is not None:
            self.duration = duration

    # Instance attribute type: CommitInfo (validator is set below)
    commit_info = bb.Attribute("commit_info", user_defined=True)

    # Instance attribute type: float (validator is set below)
    duration = bb.Attribute("duration")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetTemporaryUploadLinkArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetTemporaryUploadLinkArg_validator = bv.Struct(GetTemporaryUploadLinkArg)


class GetTemporaryUploadLinkResult(bb.Struct):
    """
    :ivar GetTemporaryUploadLinkResult.link:
        The temporary link which can be used to stream a file to a Dropbox
        location.
    """

    __slots__ = [
        "_link_value",
    ]

    _has_required_fields = True

    def __init__(self, link=None):
        self._link_value = bb.NOT_SET
        if link is not None:
            self.link = link

    # Instance attribute type: str (validator is set below)
    link = bb.Attribute("link")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetTemporaryUploadLinkResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetTemporaryUploadLinkResult_validator = bv.Struct(GetTemporaryUploadLinkResult)


class GetThumbnailBatchArg(bb.Struct):
    """
    Arguments for
    :meth:`dropbox.dropbox_client.Dropbox.files_get_thumbnail_batch`.

    :ivar GetThumbnailBatchArg.entries:
        List of files to get thumbnails.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [ThumbnailArg] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetThumbnailBatchArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetThumbnailBatchArg_validator = bv.Struct(GetThumbnailBatchArg)


class GetThumbnailBatchError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar GetThumbnailBatchError.too_many_files:
        The operation involves more than 25 files.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    too_many_files = None
    # Attribute is overwritten below the class definition
    other = None

    def is_too_many_files(self):
        """
        Check if the union tag is ``too_many_files``.

        :rtype: bool
        """
        return self._tag == "too_many_files"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetThumbnailBatchError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetThumbnailBatchError_validator = bv.Union(GetThumbnailBatchError)


class GetThumbnailBatchResult(bb.Struct):
    """
    :ivar GetThumbnailBatchResult.entries:
        List of files and their thumbnails.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [GetThumbnailBatchResultEntry] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetThumbnailBatchResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetThumbnailBatchResult_validator = bv.Struct(GetThumbnailBatchResult)


class GetThumbnailBatchResultData(bb.Struct):
    """
    :ivar GetThumbnailBatchResultData.thumbnail:
        A string containing the base64-encoded thumbnail data for this file.
    """

    __slots__ = [
        "_metadata_value",
        "_thumbnail_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None, thumbnail=None):
        self._metadata_value = bb.NOT_SET
        self._thumbnail_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata
        if thumbnail is not None:
            self.thumbnail = thumbnail

    # Instance attribute type: FileMetadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    # Instance attribute type: str (validator is set below)
    thumbnail = bb.Attribute("thumbnail")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetThumbnailBatchResultData, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetThumbnailBatchResultData_validator = bv.Struct(GetThumbnailBatchResultData)


class GetThumbnailBatchResultEntry(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar GetThumbnailBatchResultEntry.failure:
        The result for this file if it was an error.
    :vartype GetThumbnailBatchResultEntry.failure: ThumbnailError
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def success(cls, val):
        """
        Create an instance of this class set to the ``success`` tag with value
        ``val``.

        :param GetThumbnailBatchResultData val:
        :rtype: GetThumbnailBatchResultEntry
        """
        return cls("success", val)

    @classmethod
    def failure(cls, val):
        """
        Create an instance of this class set to the ``failure`` tag with value
        ``val``.

        :param ThumbnailError val:
        :rtype: GetThumbnailBatchResultEntry
        """
        return cls("failure", val)

    def is_success(self):
        """
        Check if the union tag is ``success``.

        :rtype: bool
        """
        return self._tag == "success"

    def is_failure(self):
        """
        Check if the union tag is ``failure``.

        :rtype: bool
        """
        return self._tag == "failure"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_success(self):
        """
        Only call this if :meth:`is_success` is true.

        :rtype: GetThumbnailBatchResultData
        """
        if not self.is_success():
            raise AttributeError("tag 'success' not set")
        return self._value

    def get_failure(self):
        """
        The result for this file if it was an error.

        Only call this if :meth:`is_failure` is true.

        :rtype: ThumbnailError
        """
        if not self.is_failure():
            raise AttributeError("tag 'failure' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GetThumbnailBatchResultEntry, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetThumbnailBatchResultEntry_validator = bv.Union(GetThumbnailBatchResultEntry)


class GpsCoordinates(bb.Struct):
    """
    GPS coordinates for a photo or video.

    :ivar GpsCoordinates.latitude:
        Latitude of the GPS coordinates.
    :ivar GpsCoordinates.longitude:
        Longitude of the GPS coordinates.
    """

    __slots__ = [
        "_latitude_value",
        "_longitude_value",
    ]

    _has_required_fields = True

    def __init__(self, latitude=None, longitude=None):
        self._latitude_value = bb.NOT_SET
        self._longitude_value = bb.NOT_SET
        if latitude is not None:
            self.latitude = latitude
        if longitude is not None:
            self.longitude = longitude

    # Instance attribute type: float (validator is set below)
    latitude = bb.Attribute("latitude")

    # Instance attribute type: float (validator is set below)
    longitude = bb.Attribute("longitude")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(GpsCoordinates, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GpsCoordinates_validator = bv.Struct(GpsCoordinates)


class HighlightSpan(bb.Struct):
    """
    :ivar HighlightSpan.highlight_str:
        String to be determined whether it should be highlighted or not.
    :ivar HighlightSpan.is_highlighted:
        The string should be highlighted or not.
    """

    __slots__ = [
        "_highlight_str_value",
        "_is_highlighted_value",
    ]

    _has_required_fields = True

    def __init__(self, highlight_str=None, is_highlighted=None):
        self._highlight_str_value = bb.NOT_SET
        self._is_highlighted_value = bb.NOT_SET
        if highlight_str is not None:
            self.highlight_str = highlight_str
        if is_highlighted is not None:
            self.is_highlighted = is_highlighted

    # Instance attribute type: str (validator is set below)
    highlight_str = bb.Attribute("highlight_str")

    # Instance attribute type: bool (validator is set below)
    is_highlighted = bb.Attribute("is_highlighted")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(HighlightSpan, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


HighlightSpan_validator = bv.Struct(HighlightSpan)


class ImportFormat(bb.Union):
    """
    The import format of the incoming Paper doc content.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ImportFormat.html:
        The provided data is interpreted as standard HTML.
    :ivar ImportFormat.markdown:
        The provided data is interpreted as markdown.
    :ivar ImportFormat.plain_text:
        The provided data is interpreted as plain text.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    html = None
    # Attribute is overwritten below the class definition
    markdown = None
    # Attribute is overwritten below the class definition
    plain_text = None
    # Attribute is overwritten below the class definition
    other = None

    def is_html(self):
        """
        Check if the union tag is ``html``.

        :rtype: bool
        """
        return self._tag == "html"

    def is_markdown(self):
        """
        Check if the union tag is ``markdown``.

        :rtype: bool
        """
        return self._tag == "markdown"

    def is_plain_text(self):
        """
        Check if the union tag is ``plain_text``.

        :rtype: bool
        """
        return self._tag == "plain_text"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ImportFormat, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ImportFormat_validator = bv.Union(ImportFormat)


class ListFolderArg(bb.Struct):
    """
    :ivar ListFolderArg.path:
        A unique identifier for the file.
    :ivar ListFolderArg.recursive:
        If true, the list folder operation will be applied recursively to all
        subfolders and the response will contain contents of all subfolders. In
        some cases, setting ``ListFolderArg.recursive`` to ``True`` may lead to
        performance issues or errors, especially when traversing folder
        structures with a large number of items. A workaround for such cases is
        to set ``ListFolderArg.recursive`` to ``False`` and traverse subfolders
        one at a time.
    :ivar ListFolderArg.include_media_info:
        Field is deprecated. If true, ``FileMetadata.media_info`` is set for
        photo and video. This parameter will no longer have an effect starting
        December 2, 2019.
    :ivar ListFolderArg.include_deleted:
        If true, the results will include entries for files and folders that
        used to exist but were deleted.
    :ivar ListFolderArg.include_has_explicit_shared_members:
        If true, the results will include a flag for each file indicating
        whether or not that file has any explicit members.
    :ivar ListFolderArg.include_mounted_folders:
        If true, the results will include entries under mounted folders which
        includes app folder, shared folder and team folder.
    :ivar ListFolderArg.limit:
        The maximum number of results to return per request. Note: This is an
        approximate number and there can be slightly more entries returned in
        some cases.
    :ivar ListFolderArg.shared_link:
        A shared link to list the contents of. If the link is
        password-protected, the password must be provided. If this field is
        present, ``ListFolderArg.path`` will be relative to root of the shared
        link. Only non-recursive mode is supported for shared link.
    :ivar ListFolderArg.include_property_groups:
        If set to a valid list of template IDs, ``FileMetadata.property_groups``
        is set if there exists property data associated with the file and each
        of the listed templates.
    :ivar ListFolderArg.include_non_downloadable_files:
        If true, include files that are not downloadable, i.e. Google Docs.
    :ivar ListFolderArg.include_restorable_info:
        If true, each returned deleted entry will include whether that entry can
        be restored.
    """

    __slots__ = [
        "_path_value",
        "_recursive_value",
        "_include_media_info_value",
        "_include_deleted_value",
        "_include_has_explicit_shared_members_value",
        "_include_mounted_folders_value",
        "_limit_value",
        "_shared_link_value",
        "_include_property_groups_value",
        "_include_non_downloadable_files_value",
        "_include_restorable_info_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        path=None,
        recursive=None,
        include_media_info=None,
        include_deleted=None,
        include_has_explicit_shared_members=None,
        include_mounted_folders=None,
        limit=None,
        shared_link=None,
        include_property_groups=None,
        include_non_downloadable_files=None,
        include_restorable_info=None,
    ):
        self._path_value = bb.NOT_SET
        self._recursive_value = bb.NOT_SET
        self._include_media_info_value = bb.NOT_SET
        self._include_deleted_value = bb.NOT_SET
        self._include_has_explicit_shared_members_value = bb.NOT_SET
        self._include_mounted_folders_value = bb.NOT_SET
        self._limit_value = bb.NOT_SET
        self._shared_link_value = bb.NOT_SET
        self._include_property_groups_value = bb.NOT_SET
        self._include_non_downloadable_files_value = bb.NOT_SET
        self._include_restorable_info_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if recursive is not None:
            self.recursive = recursive
        if include_media_info is not None:
            self.include_media_info = include_media_info
        if include_deleted is not None:
            self.include_deleted = include_deleted
        if include_has_explicit_shared_members is not None:
            self.include_has_explicit_shared_members = include_has_explicit_shared_members
        if include_mounted_folders is not None:
            self.include_mounted_folders = include_mounted_folders
        if limit is not None:
            self.limit = limit
        if shared_link is not None:
            self.shared_link = shared_link
        if include_property_groups is not None:
            self.include_property_groups = include_property_groups
        if include_non_downloadable_files is not None:
            self.include_non_downloadable_files = include_non_downloadable_files
        if include_restorable_info is not None:
            self.include_restorable_info = include_restorable_info

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: bool (validator is set below)
    recursive = bb.Attribute("recursive")

    # Instance attribute type: bool (validator is set below)
    include_media_info = bb.Attribute("include_media_info")

    # Instance attribute type: bool (validator is set below)
    include_deleted = bb.Attribute("include_deleted")

    # Instance attribute type: bool (validator is set below)
    include_has_explicit_shared_members = bb.Attribute("include_has_explicit_shared_members")

    # Instance attribute type: bool (validator is set below)
    include_mounted_folders = bb.Attribute("include_mounted_folders")

    # Instance attribute type: int (validator is set below)
    limit = bb.Attribute("limit", nullable=True)

    # Instance attribute type: SharedLink (validator is set below)
    shared_link = bb.Attribute("shared_link", nullable=True, user_defined=True)

    # Instance attribute type: file_properties.TemplateFilterBase (validator is set below)
    include_property_groups = bb.Attribute(
        "include_property_groups", nullable=True, user_defined=True
    )

    # Instance attribute type: bool (validator is set below)
    include_non_downloadable_files = bb.Attribute("include_non_downloadable_files")

    # Instance attribute type: bool (validator is set below)
    include_restorable_info = bb.Attribute("include_restorable_info")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListFolderArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListFolderArg_validator = bv.Struct(ListFolderArg)


class ListFolderContinueArg(bb.Struct):
    """
    :ivar ListFolderContinueArg.cursor:
        The cursor returned by your last call to
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder` or
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder_continue`.
    """

    __slots__ = [
        "_cursor_value",
    ]

    _has_required_fields = True

    def __init__(self, cursor=None):
        self._cursor_value = bb.NOT_SET
        if cursor is not None:
            self.cursor = cursor

    # Instance attribute type: str (validator is set below)
    cursor = bb.Attribute("cursor")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListFolderContinueArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListFolderContinueArg_validator = bv.Struct(ListFolderContinueArg)


class ListFolderContinueError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ListFolderContinueError.reset:
        Indicates that the cursor has been invalidated. Call
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder` to obtain a new
        cursor.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    reset = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: ListFolderContinueError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_reset(self):
        """
        Check if the union tag is ``reset``.

        :rtype: bool
        """
        return self._tag == "reset"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListFolderContinueError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListFolderContinueError_validator = bv.Union(ListFolderContinueError)


class ListFolderError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: ListFolderError
        """
        return cls("path", val)

    @classmethod
    def template_error(cls, val):
        """
        Create an instance of this class set to the ``template_error`` tag with
        value ``val``.

        :param file_properties.TemplateError val:
        :rtype: ListFolderError
        """
        return cls("template_error", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_template_error(self):
        """
        Check if the union tag is ``template_error``.

        :rtype: bool
        """
        return self._tag == "template_error"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def get_template_error(self):
        """
        Only call this if :meth:`is_template_error` is true.

        :rtype: file_properties.TemplateError
        """
        if not self.is_template_error():
            raise AttributeError("tag 'template_error' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListFolderError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListFolderError_validator = bv.Union(ListFolderError)


class ListFolderGetLatestCursorResult(bb.Struct):
    """
    :ivar ListFolderGetLatestCursorResult.cursor:
        Pass the cursor into
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder_continue` to see
        what's changed in the folder since your previous query.
    """

    __slots__ = [
        "_cursor_value",
    ]

    _has_required_fields = True

    def __init__(self, cursor=None):
        self._cursor_value = bb.NOT_SET
        if cursor is not None:
            self.cursor = cursor

    # Instance attribute type: str (validator is set below)
    cursor = bb.Attribute("cursor")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListFolderGetLatestCursorResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListFolderGetLatestCursorResult_validator = bv.Struct(ListFolderGetLatestCursorResult)


class ListFolderLongpollArg(bb.Struct):
    """
    :ivar ListFolderLongpollArg.cursor:
        A cursor as returned by
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder` or
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder_continue`.
        Cursors retrieved by setting ``ListFolderArg.include_media_info`` to
        ``True`` are not supported.
    :ivar ListFolderLongpollArg.timeout:
        A timeout in seconds. The request will block for at most this length of
        time, plus up to 90 seconds of random jitter added to avoid the
        thundering herd problem. Care should be taken when using this parameter,
        as some network infrastructure does not support long timeouts.
    """

    __slots__ = [
        "_cursor_value",
        "_timeout_value",
    ]

    _has_required_fields = True

    def __init__(self, cursor=None, timeout=None):
        self._cursor_value = bb.NOT_SET
        self._timeout_value = bb.NOT_SET
        if cursor is not None:
            self.cursor = cursor
        if timeout is not None:
            self.timeout = timeout

    # Instance attribute type: str (validator is set below)
    cursor = bb.Attribute("cursor")

    # Instance attribute type: int (validator is set below)
    timeout = bb.Attribute("timeout")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListFolderLongpollArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListFolderLongpollArg_validator = bv.Struct(ListFolderLongpollArg)


class ListFolderLongpollError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ListFolderLongpollError.reset:
        Indicates that the cursor has been invalidated. Call
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder` to obtain a new
        cursor.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    reset = None
    # Attribute is overwritten below the class definition
    other = None

    def is_reset(self):
        """
        Check if the union tag is ``reset``.

        :rtype: bool
        """
        return self._tag == "reset"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListFolderLongpollError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListFolderLongpollError_validator = bv.Union(ListFolderLongpollError)


class ListFolderLongpollResult(bb.Struct):
    """
    :ivar ListFolderLongpollResult.changes:
        Indicates whether new changes are available. If true, call
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder_continue` to
        retrieve the changes.
    :ivar ListFolderLongpollResult.backoff:
        If present, backoff for at least this many seconds before calling
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder_longpoll` again.
    """

    __slots__ = [
        "_changes_value",
        "_backoff_value",
    ]

    _has_required_fields = True

    def __init__(self, changes=None, backoff=None):
        self._changes_value = bb.NOT_SET
        self._backoff_value = bb.NOT_SET
        if changes is not None:
            self.changes = changes
        if backoff is not None:
            self.backoff = backoff

    # Instance attribute type: bool (validator is set below)
    changes = bb.Attribute("changes")

    # Instance attribute type: int (validator is set below)
    backoff = bb.Attribute("backoff", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListFolderLongpollResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListFolderLongpollResult_validator = bv.Struct(ListFolderLongpollResult)


class ListFolderResult(bb.Struct):
    """
    :ivar ListFolderResult.entries:
        The files and (direct) subfolders in the folder.
    :ivar ListFolderResult.cursor:
        Pass the cursor into
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder_continue` to see
        what's changed in the folder since your previous query.
    :ivar ListFolderResult.has_more:
        If true, then there are more entries available. Pass the cursor to
        :meth:`dropbox.dropbox_client.Dropbox.files_list_folder_continue` to
        retrieve the rest.
    """

    __slots__ = [
        "_entries_value",
        "_cursor_value",
        "_has_more_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None, cursor=None, has_more=None):
        self._entries_value = bb.NOT_SET
        self._cursor_value = bb.NOT_SET
        self._has_more_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries
        if cursor is not None:
            self.cursor = cursor
        if has_more is not None:
            self.has_more = has_more

    # Instance attribute type: list of [Metadata] (validator is set below)
    entries = bb.Attribute("entries")

    # Instance attribute type: str (validator is set below)
    cursor = bb.Attribute("cursor")

    # Instance attribute type: bool (validator is set below)
    has_more = bb.Attribute("has_more")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListFolderResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListFolderResult_validator = bv.Struct(ListFolderResult)


class ListRevisionsArg(bb.Struct):
    """
    :ivar ListRevisionsArg.path:
        The path to the file you want to see the revisions of.
    :ivar ListRevisionsArg.mode:
        Determines the behavior of the API in listing the revisions for a given
        file path or id.
    :ivar ListRevisionsArg.limit:
        The maximum number of revision entries returned.
    :ivar ListRevisionsArg.before_rev:
        If set, ListRevisions will only return revisions prior to before_rev.
        Can be set using the last revision from a previous call to
        list_revisions to fetch the next page of revisions. Only supported in
        path mode.
    :ivar ListRevisionsArg.include_restorable_info:
        If true, each returned revision will include whether that revision can
        be restored.
    """

    __slots__ = [
        "_path_value",
        "_mode_value",
        "_limit_value",
        "_before_rev_value",
        "_include_restorable_info_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        path=None,
        mode=None,
        limit=None,
        before_rev=None,
        include_restorable_info=None,
    ):
        self._path_value = bb.NOT_SET
        self._mode_value = bb.NOT_SET
        self._limit_value = bb.NOT_SET
        self._before_rev_value = bb.NOT_SET
        self._include_restorable_info_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if mode is not None:
            self.mode = mode
        if limit is not None:
            self.limit = limit
        if before_rev is not None:
            self.before_rev = before_rev
        if include_restorable_info is not None:
            self.include_restorable_info = include_restorable_info

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: ListRevisionsMode (validator is set below)
    mode = bb.Attribute("mode", user_defined=True)

    # Instance attribute type: int (validator is set below)
    limit = bb.Attribute("limit")

    # Instance attribute type: str (validator is set below)
    before_rev = bb.Attribute("before_rev", nullable=True)

    # Instance attribute type: bool (validator is set below)
    include_restorable_info = bb.Attribute("include_restorable_info")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListRevisionsArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListRevisionsArg_validator = bv.Struct(ListRevisionsArg)


class ListRevisionsError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ListRevisionsError.invalid_before_rev:
        The revision in before_rev is invalid.
    :ivar ListRevisionsError.before_rev_not_supported:
        The before_rev argument is only supported in path mode.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    invalid_before_rev = None
    # Attribute is overwritten below the class definition
    before_rev_not_supported = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: ListRevisionsError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_invalid_before_rev(self):
        """
        Check if the union tag is ``invalid_before_rev``.

        :rtype: bool
        """
        return self._tag == "invalid_before_rev"

    def is_before_rev_not_supported(self):
        """
        Check if the union tag is ``before_rev_not_supported``.

        :rtype: bool
        """
        return self._tag == "before_rev_not_supported"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListRevisionsError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListRevisionsError_validator = bv.Union(ListRevisionsError)


class ListRevisionsMode(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ListRevisionsMode.path:
        Returns revisions with the same file path as identified by the latest
        file entry at the given file path or id.
    :ivar ListRevisionsMode.id:
        Returns revisions with the same file id as identified by the latest file
        entry at the given file path or id.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    path = None
    # Attribute is overwritten below the class definition
    id = None
    # Attribute is overwritten below the class definition
    other = None

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_id(self):
        """
        Check if the union tag is ``id``.

        :rtype: bool
        """
        return self._tag == "id"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListRevisionsMode, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListRevisionsMode_validator = bv.Union(ListRevisionsMode)


class ListRevisionsResult(bb.Struct):
    """
    :ivar ListRevisionsResult.is_deleted:
        If the file identified by the latest revision in the response is either
        deleted or moved. If before_rev is set, this refers to the latest
        revision of the file older than before_rev.
    :ivar ListRevisionsResult.server_deleted:
        The time of deletion if the file was deleted.
    :ivar ListRevisionsResult.entries:
        The revisions for the file. Only revisions that are not deleted will
        show up here.
    :ivar ListRevisionsResult.has_more:
        If true, then there are more entries available. Call list_revisions
        again with before_rev equal to the revision of the last returned entry
        to retrieve the rest.
    """

    __slots__ = [
        "_is_deleted_value",
        "_server_deleted_value",
        "_entries_value",
        "_has_more_value",
    ]

    _has_required_fields = True

    def __init__(self, is_deleted=None, entries=None, has_more=None, server_deleted=None):
        self._is_deleted_value = bb.NOT_SET
        self._server_deleted_value = bb.NOT_SET
        self._entries_value = bb.NOT_SET
        self._has_more_value = bb.NOT_SET
        if is_deleted is not None:
            self.is_deleted = is_deleted
        if server_deleted is not None:
            self.server_deleted = server_deleted
        if entries is not None:
            self.entries = entries
        if has_more is not None:
            self.has_more = has_more

    # Instance attribute type: bool (validator is set below)
    is_deleted = bb.Attribute("is_deleted")

    # Instance attribute type: datetime.datetime (validator is set below)
    server_deleted = bb.Attribute("server_deleted", nullable=True)

    # Instance attribute type: list of [FileMetadata] (validator is set below)
    entries = bb.Attribute("entries")

    # Instance attribute type: bool (validator is set below)
    has_more = bb.Attribute("has_more")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ListRevisionsResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ListRevisionsResult_validator = bv.Struct(ListRevisionsResult)


class LockConflictError(bb.Struct):
    """
    :ivar LockConflictError.lock:
        The lock that caused the conflict.
    """

    __slots__ = [
        "_lock_value",
    ]

    _has_required_fields = True

    def __init__(self, lock=None):
        self._lock_value = bb.NOT_SET
        if lock is not None:
            self.lock = lock

    # Instance attribute type: FileLock (validator is set below)
    lock = bb.Attribute("lock", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(LockConflictError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


LockConflictError_validator = bv.Struct(LockConflictError)


class LockFileArg(bb.Struct):
    """
    :ivar LockFileArg.path:
        Path in the user's Dropbox to a file.
    """

    __slots__ = [
        "_path_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None):
        self._path_value = bb.NOT_SET
        if path is not None:
            self.path = path

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(LockFileArg, self)._process_custom_annotations(annotation_type, field_path, processor)


LockFileArg_validator = bv.Struct(LockFileArg)


class LockFileBatchArg(bb.Struct):
    """
    :ivar LockFileBatchArg.entries:
        List of 'entries'. Each 'entry' contains a path of the file which will
        be locked or queried. Duplicate path arguments in the batch are
        considered only once.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [LockFileArg] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(LockFileBatchArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


LockFileBatchArg_validator = bv.Struct(LockFileBatchArg)


class LockFileBatchResult(FileOpsResult):
    """
    :ivar LockFileBatchResult.entries:
        Each Entry in the 'entries' will have '.tag' with the operation status
        (e.g. success), the metadata for the file and the lock state after the
        operation.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        super(LockFileBatchResult, self).__init__()
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [LockFileResultEntry] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(LockFileBatchResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


LockFileBatchResult_validator = bv.Struct(LockFileBatchResult)


class LockFileError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar LockFileError.path_lookup:
        Could not find the specified resource.
    :vartype LockFileError.path_lookup: LookupError
    :ivar LockFileError.too_many_write_operations:
        There are too many write operations in user's Dropbox. Please retry this
        request.
    :ivar LockFileError.too_many_files:
        There are too many files in one request. Please retry with fewer files.
    :ivar LockFileError.no_write_permission:
        The user does not have permissions to change the lock state or access
        the file.
    :ivar LockFileError.cannot_be_locked:
        Item is a type that cannot be locked.
    :ivar LockFileError.file_not_shared:
        Requested file is not currently shared.
    :ivar LockFileError.lock_conflict:
        The user action conflicts with an existing lock on the file.
    :vartype LockFileError.lock_conflict: LockConflictError
    :ivar LockFileError.internal_error:
        Something went wrong with the job on Dropbox's end. You'll need to
        verify that the action you were taking succeeded, and if not, try again.
        This should happen very rarely.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    too_many_write_operations = None
    # Attribute is overwritten below the class definition
    too_many_files = None
    # Attribute is overwritten below the class definition
    no_write_permission = None
    # Attribute is overwritten below the class definition
    cannot_be_locked = None
    # Attribute is overwritten below the class definition
    file_not_shared = None
    # Attribute is overwritten below the class definition
    internal_error = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path_lookup(cls, val):
        """
        Create an instance of this class set to the ``path_lookup`` tag with
        value ``val``.

        :param LookupError val:
        :rtype: LockFileError
        """
        return cls("path_lookup", val)

    @classmethod
    def lock_conflict(cls, val):
        """
        Create an instance of this class set to the ``lock_conflict`` tag with
        value ``val``.

        :param LockConflictError val:
        :rtype: LockFileError
        """
        return cls("lock_conflict", val)

    def is_path_lookup(self):
        """
        Check if the union tag is ``path_lookup``.

        :rtype: bool
        """
        return self._tag == "path_lookup"

    def is_too_many_write_operations(self):
        """
        Check if the union tag is ``too_many_write_operations``.

        :rtype: bool
        """
        return self._tag == "too_many_write_operations"

    def is_too_many_files(self):
        """
        Check if the union tag is ``too_many_files``.

        :rtype: bool
        """
        return self._tag == "too_many_files"

    def is_no_write_permission(self):
        """
        Check if the union tag is ``no_write_permission``.

        :rtype: bool
        """
        return self._tag == "no_write_permission"

    def is_cannot_be_locked(self):
        """
        Check if the union tag is ``cannot_be_locked``.

        :rtype: bool
        """
        return self._tag == "cannot_be_locked"

    def is_file_not_shared(self):
        """
        Check if the union tag is ``file_not_shared``.

        :rtype: bool
        """
        return self._tag == "file_not_shared"

    def is_lock_conflict(self):
        """
        Check if the union tag is ``lock_conflict``.

        :rtype: bool
        """
        return self._tag == "lock_conflict"

    def is_internal_error(self):
        """
        Check if the union tag is ``internal_error``.

        :rtype: bool
        """
        return self._tag == "internal_error"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path_lookup(self):
        """
        Could not find the specified resource.

        Only call this if :meth:`is_path_lookup` is true.

        :rtype: LookupError
        """
        if not self.is_path_lookup():
            raise AttributeError("tag 'path_lookup' not set")
        return self._value

    def get_lock_conflict(self):
        """
        The user action conflicts with an existing lock on the file.

        Only call this if :meth:`is_lock_conflict` is true.

        :rtype: LockConflictError
        """
        if not self.is_lock_conflict():
            raise AttributeError("tag 'lock_conflict' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(LockFileError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


LockFileError_validator = bv.Union(LockFileError)


class LockFileResult(bb.Struct):
    """
    :ivar LockFileResult.metadata:
        Metadata of the file.
    :ivar LockFileResult.lock:
        Field is deprecated. The file lock state after the operation.
    """

    __slots__ = [
        "_metadata_value",
        "_lock_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None, lock=None):
        self._metadata_value = bb.NOT_SET
        self._lock_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata
        if lock is not None:
            self.lock = lock

    # Instance attribute type: Metadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    # Instance attribute type: FileLock (validator is set below)
    lock = bb.Attribute("lock", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(LockFileResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


LockFileResult_validator = bv.Struct(LockFileResult)


class LockFileResultEntry(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = None

    @classmethod
    def success(cls, val):
        """
        Create an instance of this class set to the ``success`` tag with value
        ``val``.

        :param LockFileResult val:
        :rtype: LockFileResultEntry
        """
        return cls("success", val)

    @classmethod
    def failure(cls, val):
        """
        Create an instance of this class set to the ``failure`` tag with value
        ``val``.

        :param LockFileError val:
        :rtype: LockFileResultEntry
        """
        return cls("failure", val)

    def is_success(self):
        """
        Check if the union tag is ``success``.

        :rtype: bool
        """
        return self._tag == "success"

    def is_failure(self):
        """
        Check if the union tag is ``failure``.

        :rtype: bool
        """
        return self._tag == "failure"

    def get_success(self):
        """
        Only call this if :meth:`is_success` is true.

        :rtype: LockFileResult
        """
        if not self.is_success():
            raise AttributeError("tag 'success' not set")
        return self._value

    def get_failure(self):
        """
        Only call this if :meth:`is_failure` is true.

        :rtype: LockFileError
        """
        if not self.is_failure():
            raise AttributeError("tag 'failure' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(LockFileResultEntry, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


LockFileResultEntry_validator = bv.Union(LockFileResultEntry)


class LookupError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar LookupError.malformed_path:
        The given path does not satisfy the required path format. Please refer
        to the `Path formats documentation
        <https://www.dropbox.com/developers/documentation/http/documentation#path-formats>`_
        for more information.
    :vartype LookupError.malformed_path: Optional[str]
    :ivar LookupError.not_found:
        There is nothing at the given path.
    :ivar LookupError.not_file:
        We were expecting a file, but the given path refers to something that
        isn't a file.
    :ivar LookupError.not_folder:
        We were expecting a folder, but the given path refers to something that
        isn't a folder.
    :ivar LookupError.restricted_content:
        The file cannot be transferred because the content is restricted. For
        example, we might restrict a file due to legal requirements.
    :ivar LookupError.unsupported_content_type:
        This operation is not supported for this content type.
    :ivar LookupError.locked:
        The given path is locked.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    not_found = None
    # Attribute is overwritten below the class definition
    not_file = None
    # Attribute is overwritten below the class definition
    not_folder = None
    # Attribute is overwritten below the class definition
    restricted_content = None
    # Attribute is overwritten below the class definition
    unsupported_content_type = None
    # Attribute is overwritten below the class definition
    locked = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def malformed_path(cls, val):
        """
        Create an instance of this class set to the ``malformed_path`` tag with
        value ``val``.

        :param Optional[str] val:
        :rtype: LookupError
        """
        return cls("malformed_path", val)

    def is_malformed_path(self):
        """
        Check if the union tag is ``malformed_path``.

        :rtype: bool
        """
        return self._tag == "malformed_path"

    def is_not_found(self):
        """
        Check if the union tag is ``not_found``.

        :rtype: bool
        """
        return self._tag == "not_found"

    def is_not_file(self):
        """
        Check if the union tag is ``not_file``.

        :rtype: bool
        """
        return self._tag == "not_file"

    def is_not_folder(self):
        """
        Check if the union tag is ``not_folder``.

        :rtype: bool
        """
        return self._tag == "not_folder"

    def is_restricted_content(self):
        """
        Check if the union tag is ``restricted_content``.

        :rtype: bool
        """
        return self._tag == "restricted_content"

    def is_unsupported_content_type(self):
        """
        Check if the union tag is ``unsupported_content_type``.

        :rtype: bool
        """
        return self._tag == "unsupported_content_type"

    def is_locked(self):
        """
        Check if the union tag is ``locked``.

        :rtype: bool
        """
        return self._tag == "locked"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_malformed_path(self):
        """
        The given path does not satisfy the required path format. Please refer
        to the `Path formats documentation
        <https://www.dropbox.com/developers/documentation/http/documentation#path-formats>`_
        for more information.

        Only call this if :meth:`is_malformed_path` is true.

        :rtype: Optional[str]
        """
        if not self.is_malformed_path():
            raise AttributeError("tag 'malformed_path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(LookupError, self)._process_custom_annotations(annotation_type, field_path, processor)


LookupError_validator = bv.Union(LookupError)


class MediaInfo(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar MediaInfo.pending:
        Indicate the photo/video is still under processing and metadata is not
        available yet.
    :ivar MediaInfo.metadata:
        The metadata for the photo/video. Uses MediaMetadataAbstract to preserve
        photo/video subtypes (e.g. VideoMetadata.duration).
    :vartype MediaInfo.metadata: MediaMetadata
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    pending = None

    @classmethod
    def metadata(cls, val):
        """
        Create an instance of this class set to the ``metadata`` tag with value
        ``val``.

        :param MediaMetadata val:
        :rtype: MediaInfo
        """
        return cls("metadata", val)

    def is_pending(self):
        """
        Check if the union tag is ``pending``.

        :rtype: bool
        """
        return self._tag == "pending"

    def is_metadata(self):
        """
        Check if the union tag is ``metadata``.

        :rtype: bool
        """
        return self._tag == "metadata"

    def get_metadata(self):
        """
        The metadata for the photo/video. Uses MediaMetadataAbstract to preserve
        photo/video subtypes (e.g. VideoMetadata.duration).

        Only call this if :meth:`is_metadata` is true.

        :rtype: MediaMetadata
        """
        if not self.is_metadata():
            raise AttributeError("tag 'metadata' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(MediaInfo, self)._process_custom_annotations(annotation_type, field_path, processor)


MediaInfo_validator = bv.Union(MediaInfo)


class MediaMetadata(bb.Struct):
    """
    Metadata for a photo or video.

    :ivar MediaMetadata.dimensions:
        Dimension of the photo/video.
    :ivar MediaMetadata.location:
        The GPS coordinate of the photo/video.
    :ivar MediaMetadata.time_taken:
        The timestamp when the photo/video is taken.
    """

    __slots__ = [
        "_dimensions_value",
        "_location_value",
        "_time_taken_value",
    ]

    _has_required_fields = False

    def __init__(self, dimensions=None, location=None, time_taken=None):
        self._dimensions_value = bb.NOT_SET
        self._location_value = bb.NOT_SET
        self._time_taken_value = bb.NOT_SET
        if dimensions is not None:
            self.dimensions = dimensions
        if location is not None:
            self.location = location
        if time_taken is not None:
            self.time_taken = time_taken

    # Instance attribute type: Dimensions (validator is set below)
    dimensions = bb.Attribute("dimensions", nullable=True, user_defined=True)

    # Instance attribute type: GpsCoordinates (validator is set below)
    location = bb.Attribute("location", nullable=True, user_defined=True)

    # Instance attribute type: datetime.datetime (validator is set below)
    time_taken = bb.Attribute("time_taken", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(MediaMetadata, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


MediaMetadata_validator = bv.StructTree(MediaMetadata)


class MetadataV2(bb.Union):
    """
    Metadata for a file, folder or other resource types.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def metadata(cls, val):
        """
        Create an instance of this class set to the ``metadata`` tag with value
        ``val``.

        :param Metadata val:
        :rtype: MetadataV2
        """
        return cls("metadata", val)

    def is_metadata(self):
        """
        Check if the union tag is ``metadata``.

        :rtype: bool
        """
        return self._tag == "metadata"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_metadata(self):
        """
        Only call this if :meth:`is_metadata` is true.

        :rtype: Metadata
        """
        if not self.is_metadata():
            raise AttributeError("tag 'metadata' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(MetadataV2, self)._process_custom_annotations(annotation_type, field_path, processor)


MetadataV2_validator = bv.Union(MetadataV2)


class MinimalFileLinkMetadata(bb.Struct):
    """
    :ivar MinimalFileLinkMetadata.url:
        URL of the shared link.
    :ivar MinimalFileLinkMetadata.id:
        Unique identifier for the linked file.
    :ivar MinimalFileLinkMetadata.path:
        Full path in the user's Dropbox. This always starts with a slash. This
        field will only be present only if the linked file is in the
        authenticated user's Dropbox.
    :ivar MinimalFileLinkMetadata.rev:
        A unique identifier for the current revision of a file. This field is
        the same rev as elsewhere in the API and can be used to detect changes
        and avoid conflicts.
    """

    __slots__ = [
        "_url_value",
        "_id_value",
        "_path_value",
        "_rev_value",
    ]

    _has_required_fields = True

    def __init__(self, url=None, rev=None, id=None, path=None):
        self._url_value = bb.NOT_SET
        self._id_value = bb.NOT_SET
        self._path_value = bb.NOT_SET
        self._rev_value = bb.NOT_SET
        if url is not None:
            self.url = url
        if id is not None:
            self.id = id
        if path is not None:
            self.path = path
        if rev is not None:
            self.rev = rev

    # Instance attribute type: str (validator is set below)
    url = bb.Attribute("url")

    # Instance attribute type: str (validator is set below)
    id = bb.Attribute("id", nullable=True)

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path", nullable=True)

    # Instance attribute type: str (validator is set below)
    rev = bb.Attribute("rev")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(MinimalFileLinkMetadata, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


MinimalFileLinkMetadata_validator = bv.Struct(MinimalFileLinkMetadata)


class RelocationBatchArgBase(bb.Struct):
    """
    :ivar RelocationBatchArgBase.entries:
        List of entries to be moved or copied. Each entry is
        :class:`RelocationPath`.
    :ivar RelocationBatchArgBase.autorename:
        If there's a conflict with any file, have the Dropbox server try to
        autorename that file to avoid the conflict.
    """

    __slots__ = [
        "_entries_value",
        "_autorename_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None, autorename=None):
        self._entries_value = bb.NOT_SET
        self._autorename_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries
        if autorename is not None:
            self.autorename = autorename

    # Instance attribute type: list of [RelocationPath] (validator is set below)
    entries = bb.Attribute("entries")

    # Instance attribute type: bool (validator is set below)
    autorename = bb.Attribute("autorename")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchArgBase, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchArgBase_validator = bv.Struct(RelocationBatchArgBase)


class MoveBatchArg(RelocationBatchArgBase):
    """
    :ivar MoveBatchArg.allow_ownership_transfer:
        Allow moves by owner even if it would result in an ownership transfer
        for the content being moved. This does not apply to copies.
    """

    __slots__ = [
        "_allow_ownership_transfer_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None, autorename=None, allow_ownership_transfer=None):
        super(MoveBatchArg, self).__init__(entries, autorename)
        self._allow_ownership_transfer_value = bb.NOT_SET
        if allow_ownership_transfer is not None:
            self.allow_ownership_transfer = allow_ownership_transfer

    # Instance attribute type: bool (validator is set below)
    allow_ownership_transfer = bb.Attribute("allow_ownership_transfer")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(MoveBatchArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


MoveBatchArg_validator = bv.Struct(MoveBatchArg)


class MoveIntoFamilyError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar MoveIntoFamilyError.is_shared_folder:
        Moving shared folder into Family Room folder is not allowed.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    is_shared_folder = None
    # Attribute is overwritten below the class definition
    other = None

    def is_is_shared_folder(self):
        """
        Check if the union tag is ``is_shared_folder``.

        :rtype: bool
        """
        return self._tag == "is_shared_folder"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(MoveIntoFamilyError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


MoveIntoFamilyError_validator = bv.Union(MoveIntoFamilyError)


class MoveIntoVaultError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar MoveIntoVaultError.is_shared_folder:
        Moving shared folder into Vault is not allowed.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    is_shared_folder = None
    # Attribute is overwritten below the class definition
    other = None

    def is_is_shared_folder(self):
        """
        Check if the union tag is ``is_shared_folder``.

        :rtype: bool
        """
        return self._tag == "is_shared_folder"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(MoveIntoVaultError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


MoveIntoVaultError_validator = bv.Union(MoveIntoVaultError)


class PaperContentError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar PaperContentError.insufficient_permissions:
        Your account does not have permissions to edit Paper docs.
    :ivar PaperContentError.content_malformed:
        The provided content was malformed and cannot be imported to Paper.
    :ivar PaperContentError.doc_length_exceeded:
        The Paper doc would be too large, split the content into multiple docs.
    :ivar PaperContentError.image_size_exceeded:
        The imported document contains an image that is too large. The current
        limit is 1MB. This only applies to HTML with data URI.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    insufficient_permissions = None
    # Attribute is overwritten below the class definition
    content_malformed = None
    # Attribute is overwritten below the class definition
    doc_length_exceeded = None
    # Attribute is overwritten below the class definition
    image_size_exceeded = None
    # Attribute is overwritten below the class definition
    other = None

    def is_insufficient_permissions(self):
        """
        Check if the union tag is ``insufficient_permissions``.

        :rtype: bool
        """
        return self._tag == "insufficient_permissions"

    def is_content_malformed(self):
        """
        Check if the union tag is ``content_malformed``.

        :rtype: bool
        """
        return self._tag == "content_malformed"

    def is_doc_length_exceeded(self):
        """
        Check if the union tag is ``doc_length_exceeded``.

        :rtype: bool
        """
        return self._tag == "doc_length_exceeded"

    def is_image_size_exceeded(self):
        """
        Check if the union tag is ``image_size_exceeded``.

        :rtype: bool
        """
        return self._tag == "image_size_exceeded"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PaperContentError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PaperContentError_validator = bv.Union(PaperContentError)


class PaperCreateArg(bb.Struct):
    """
    :ivar PaperCreateArg.path:
        The fully qualified path to the location in the user's Dropbox where the
        Paper Doc should be created. This should include the document's title
        and end with .paper.
    :ivar PaperCreateArg.import_format:
        The format of the provided data.
    """

    __slots__ = [
        "_path_value",
        "_import_format_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, import_format=None):
        self._path_value = bb.NOT_SET
        self._import_format_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if import_format is not None:
            self.import_format = import_format

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: ImportFormat (validator is set below)
    import_format = bb.Attribute("import_format", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PaperCreateArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PaperCreateArg_validator = bv.Struct(PaperCreateArg)


class PaperCreateError(PaperContentError):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar PaperCreateError.invalid_path:
        The file could not be saved to the specified location.
    :ivar PaperCreateError.email_unverified:
        The user's email must be verified to create Paper docs.
    :ivar PaperCreateError.invalid_file_extension:
        The file path must end in .paper.
    :ivar PaperCreateError.paper_disabled:
        Paper is disabled for your team.
    """

    # Attribute is overwritten below the class definition
    invalid_path = None
    # Attribute is overwritten below the class definition
    email_unverified = None
    # Attribute is overwritten below the class definition
    invalid_file_extension = None
    # Attribute is overwritten below the class definition
    paper_disabled = None

    def is_invalid_path(self):
        """
        Check if the union tag is ``invalid_path``.

        :rtype: bool
        """
        return self._tag == "invalid_path"

    def is_email_unverified(self):
        """
        Check if the union tag is ``email_unverified``.

        :rtype: bool
        """
        return self._tag == "email_unverified"

    def is_invalid_file_extension(self):
        """
        Check if the union tag is ``invalid_file_extension``.

        :rtype: bool
        """
        return self._tag == "invalid_file_extension"

    def is_paper_disabled(self):
        """
        Check if the union tag is ``paper_disabled``.

        :rtype: bool
        """
        return self._tag == "paper_disabled"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PaperCreateError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PaperCreateError_validator = bv.Union(PaperCreateError)


class PaperCreateResult(bb.Struct):
    """
    :ivar PaperCreateResult.url:
        URL to open the Paper Doc.
    :ivar PaperCreateResult.result_path:
        The fully qualified path the Paper Doc was actually created at.
    :ivar PaperCreateResult.file_id:
        The id to use in Dropbox APIs when referencing the Paper Doc.
    :ivar PaperCreateResult.paper_revision:
        The current doc revision.
    """

    __slots__ = [
        "_url_value",
        "_result_path_value",
        "_file_id_value",
        "_paper_revision_value",
    ]

    _has_required_fields = True

    def __init__(self, url=None, result_path=None, file_id=None, paper_revision=None):
        self._url_value = bb.NOT_SET
        self._result_path_value = bb.NOT_SET
        self._file_id_value = bb.NOT_SET
        self._paper_revision_value = bb.NOT_SET
        if url is not None:
            self.url = url
        if result_path is not None:
            self.result_path = result_path
        if file_id is not None:
            self.file_id = file_id
        if paper_revision is not None:
            self.paper_revision = paper_revision

    # Instance attribute type: str (validator is set below)
    url = bb.Attribute("url")

    # Instance attribute type: str (validator is set below)
    result_path = bb.Attribute("result_path")

    # Instance attribute type: str (validator is set below)
    file_id = bb.Attribute("file_id")

    # Instance attribute type: int (validator is set below)
    paper_revision = bb.Attribute("paper_revision")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PaperCreateResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PaperCreateResult_validator = bv.Struct(PaperCreateResult)


class PaperDocUpdatePolicy(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar PaperDocUpdatePolicy.update:
        Sets the doc content to the provided content if the provided
        paper_revision matches the latest doc revision. Otherwise, returns an
        error.
    :ivar PaperDocUpdatePolicy.overwrite:
        Sets the doc content to the provided content without checking
        paper_revision.
    :ivar PaperDocUpdatePolicy.prepend:
        Adds the provided content to the beginning of the doc without checking
        paper_revision.
    :ivar PaperDocUpdatePolicy.append:
        Adds the provided content to the end of the doc without checking
        paper_revision.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    update = None
    # Attribute is overwritten below the class definition
    overwrite = None
    # Attribute is overwritten below the class definition
    prepend = None
    # Attribute is overwritten below the class definition
    append = None
    # Attribute is overwritten below the class definition
    other = None

    def is_update(self):
        """
        Check if the union tag is ``update``.

        :rtype: bool
        """
        return self._tag == "update"

    def is_overwrite(self):
        """
        Check if the union tag is ``overwrite``.

        :rtype: bool
        """
        return self._tag == "overwrite"

    def is_prepend(self):
        """
        Check if the union tag is ``prepend``.

        :rtype: bool
        """
        return self._tag == "prepend"

    def is_append(self):
        """
        Check if the union tag is ``append``.

        :rtype: bool
        """
        return self._tag == "append"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PaperDocUpdatePolicy, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PaperDocUpdatePolicy_validator = bv.Union(PaperDocUpdatePolicy)


class PaperUpdateArg(bb.Struct):
    """
    :ivar PaperUpdateArg.path:
        Path in the user's Dropbox to update. The path must correspond to a
        Paper doc or an error will be returned.
    :ivar PaperUpdateArg.import_format:
        The format of the provided data.
    :ivar PaperUpdateArg.doc_update_policy:
        How the provided content should be applied to the doc.
    :ivar PaperUpdateArg.paper_revision:
        The latest doc revision. Required when doc_update_policy is update. This
        value must match the current revision of the doc or error
        revision_mismatch will be returned.
    """

    __slots__ = [
        "_path_value",
        "_import_format_value",
        "_doc_update_policy_value",
        "_paper_revision_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, import_format=None, doc_update_policy=None, paper_revision=None):
        self._path_value = bb.NOT_SET
        self._import_format_value = bb.NOT_SET
        self._doc_update_policy_value = bb.NOT_SET
        self._paper_revision_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if import_format is not None:
            self.import_format = import_format
        if doc_update_policy is not None:
            self.doc_update_policy = doc_update_policy
        if paper_revision is not None:
            self.paper_revision = paper_revision

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: ImportFormat (validator is set below)
    import_format = bb.Attribute("import_format", user_defined=True)

    # Instance attribute type: PaperDocUpdatePolicy (validator is set below)
    doc_update_policy = bb.Attribute("doc_update_policy", user_defined=True)

    # Instance attribute type: int (validator is set below)
    paper_revision = bb.Attribute("paper_revision", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PaperUpdateArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PaperUpdateArg_validator = bv.Struct(PaperUpdateArg)


class PaperUpdateError(PaperContentError):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar PaperUpdateError.revision_mismatch:
        The provided revision does not match the document head.
    :ivar PaperUpdateError.doc_archived:
        This operation is not allowed on archived Paper docs.
    :ivar PaperUpdateError.doc_deleted:
        This operation is not allowed on deleted Paper docs.
    """

    # Attribute is overwritten below the class definition
    revision_mismatch = None
    # Attribute is overwritten below the class definition
    doc_archived = None
    # Attribute is overwritten below the class definition
    doc_deleted = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: PaperUpdateError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_revision_mismatch(self):
        """
        Check if the union tag is ``revision_mismatch``.

        :rtype: bool
        """
        return self._tag == "revision_mismatch"

    def is_doc_archived(self):
        """
        Check if the union tag is ``doc_archived``.

        :rtype: bool
        """
        return self._tag == "doc_archived"

    def is_doc_deleted(self):
        """
        Check if the union tag is ``doc_deleted``.

        :rtype: bool
        """
        return self._tag == "doc_deleted"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PaperUpdateError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PaperUpdateError_validator = bv.Union(PaperUpdateError)


class PaperUpdateResult(bb.Struct):
    """
    :ivar PaperUpdateResult.paper_revision:
        The current doc revision.
    """

    __slots__ = [
        "_paper_revision_value",
    ]

    _has_required_fields = True

    def __init__(self, paper_revision=None):
        self._paper_revision_value = bb.NOT_SET
        if paper_revision is not None:
            self.paper_revision = paper_revision

    # Instance attribute type: int (validator is set below)
    paper_revision = bb.Attribute("paper_revision")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PaperUpdateResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PaperUpdateResult_validator = bv.Struct(PaperUpdateResult)


class PathOrLink(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param str val:
        :rtype: PathOrLink
        """
        return cls("path", val)

    @classmethod
    def link(cls, val):
        """
        Create an instance of this class set to the ``link`` tag with value
        ``val``.

        :param SharedLinkFileInfo val:
        :rtype: PathOrLink
        """
        return cls("link", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_link(self):
        """
        Check if the union tag is ``link``.

        :rtype: bool
        """
        return self._tag == "link"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: str
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def get_link(self):
        """
        Only call this if :meth:`is_link` is true.

        :rtype: SharedLinkFileInfo
        """
        if not self.is_link():
            raise AttributeError("tag 'link' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PathOrLink, self)._process_custom_annotations(annotation_type, field_path, processor)


PathOrLink_validator = bv.Union(PathOrLink)


class PathToTags(bb.Struct):
    """
    :ivar PathToTags.path:
        Path of the item.
    :ivar PathToTags.tags:
        Tags assigned to this item.
    """

    __slots__ = [
        "_path_value",
        "_tags_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, tags=None):
        self._path_value = bb.NOT_SET
        self._tags_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if tags is not None:
            self.tags = tags

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: list of [Tag] (validator is set below)
    tags = bb.Attribute("tags")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PathToTags, self)._process_custom_annotations(annotation_type, field_path, processor)


PathToTags_validator = bv.Struct(PathToTags)


class PhotoMetadata(MediaMetadata):
    """
    Metadata for a photo.
    """

    __slots__ = []

    _has_required_fields = False

    def __init__(self, dimensions=None, location=None, time_taken=None):
        super(PhotoMetadata, self).__init__(dimensions, location, time_taken)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PhotoMetadata, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PhotoMetadata_validator = bv.Struct(PhotoMetadata)


class PreviewArg(bb.Struct):
    """
    :ivar PreviewArg.path:
        The path of the file to preview.
    :ivar PreviewArg.rev:
        Field is deprecated. Please specify revision in ``path`` instead.
    """

    __slots__ = [
        "_path_value",
        "_rev_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, rev=None):
        self._path_value = bb.NOT_SET
        self._rev_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if rev is not None:
            self.rev = rev

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: str (validator is set below)
    rev = bb.Attribute("rev", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PreviewArg, self)._process_custom_annotations(annotation_type, field_path, processor)


PreviewArg_validator = bv.Struct(PreviewArg)


class PreviewError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar PreviewError.path:
        An error occurs when downloading metadata for the file.
    :vartype PreviewError.path: LookupError
    :ivar PreviewError.in_progress:
        This preview generation is still in progress and the file is not ready
        for preview yet.
    :ivar PreviewError.unsupported_extension:
        The file extension is not supported preview generation.
    :ivar PreviewError.unsupported_content:
        The file content is not supported for preview generation.
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    in_progress = None
    # Attribute is overwritten below the class definition
    unsupported_extension = None
    # Attribute is overwritten below the class definition
    unsupported_content = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: PreviewError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_in_progress(self):
        """
        Check if the union tag is ``in_progress``.

        :rtype: bool
        """
        return self._tag == "in_progress"

    def is_unsupported_extension(self):
        """
        Check if the union tag is ``unsupported_extension``.

        :rtype: bool
        """
        return self._tag == "unsupported_extension"

    def is_unsupported_content(self):
        """
        Check if the union tag is ``unsupported_content``.

        :rtype: bool
        """
        return self._tag == "unsupported_content"

    def get_path(self):
        """
        An error occurs when downloading metadata for the file.

        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PreviewError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PreviewError_validator = bv.Union(PreviewError)


class PreviewResult(bb.Struct):
    """
    :ivar PreviewResult.file_metadata:
        Metadata corresponding to the file received as an argument. Will be
        populated if the endpoint is called with a path (ReadPath).
    :ivar PreviewResult.link_metadata:
        Minimal metadata corresponding to the file received as an argument. Will
        be populated if the endpoint is called using a shared link
        (SharedLinkFileInfo).
    """

    __slots__ = [
        "_file_metadata_value",
        "_link_metadata_value",
    ]

    _has_required_fields = False

    def __init__(self, file_metadata=None, link_metadata=None):
        self._file_metadata_value = bb.NOT_SET
        self._link_metadata_value = bb.NOT_SET
        if file_metadata is not None:
            self.file_metadata = file_metadata
        if link_metadata is not None:
            self.link_metadata = link_metadata

    # Instance attribute type: FileMetadata (validator is set below)
    file_metadata = bb.Attribute("file_metadata", nullable=True, user_defined=True)

    # Instance attribute type: MinimalFileLinkMetadata (validator is set below)
    link_metadata = bb.Attribute("link_metadata", nullable=True, user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(PreviewResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


PreviewResult_validator = bv.Struct(PreviewResult)


class RelocationPath(bb.Struct):
    """
    :ivar RelocationPath.from_path:
        Path in the user's Dropbox to be copied or moved.
    :ivar RelocationPath.to_path:
        Path in the user's Dropbox that is the destination.
    """

    __slots__ = [
        "_from_path_value",
        "_to_path_value",
    ]

    _has_required_fields = True

    def __init__(self, from_path=None, to_path=None):
        self._from_path_value = bb.NOT_SET
        self._to_path_value = bb.NOT_SET
        if from_path is not None:
            self.from_path = from_path
        if to_path is not None:
            self.to_path = to_path

    # Instance attribute type: str (validator is set below)
    from_path = bb.Attribute("from_path")

    # Instance attribute type: str (validator is set below)
    to_path = bb.Attribute("to_path")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationPath, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationPath_validator = bv.Struct(RelocationPath)


class RelocationArg(RelocationPath):
    """
    :ivar RelocationArg.allow_shared_folder:
        Field is deprecated. This flag has no effect.
    :ivar RelocationArg.autorename:
        If there's a conflict, have the Dropbox server try to autorename the
        file to avoid the conflict.
    :ivar RelocationArg.allow_ownership_transfer:
        Allow moves by owner even if it would result in an ownership transfer
        for the content being moved. This does not apply to copies.
    """

    __slots__ = [
        "_allow_shared_folder_value",
        "_autorename_value",
        "_allow_ownership_transfer_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        from_path=None,
        to_path=None,
        allow_shared_folder=None,
        autorename=None,
        allow_ownership_transfer=None,
    ):
        super(RelocationArg, self).__init__(from_path, to_path)
        self._allow_shared_folder_value = bb.NOT_SET
        self._autorename_value = bb.NOT_SET
        self._allow_ownership_transfer_value = bb.NOT_SET
        if allow_shared_folder is not None:
            self.allow_shared_folder = allow_shared_folder
        if autorename is not None:
            self.autorename = autorename
        if allow_ownership_transfer is not None:
            self.allow_ownership_transfer = allow_ownership_transfer

    # Instance attribute type: bool (validator is set below)
    allow_shared_folder = bb.Attribute("allow_shared_folder")

    # Instance attribute type: bool (validator is set below)
    autorename = bb.Attribute("autorename")

    # Instance attribute type: bool (validator is set below)
    allow_ownership_transfer = bb.Attribute("allow_ownership_transfer")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationArg_validator = bv.Struct(RelocationArg)


class RelocationBatchArg(RelocationBatchArgBase):
    """
    :ivar RelocationBatchArg.allow_shared_folder:
        Field is deprecated. This flag has no effect.
    :ivar RelocationBatchArg.allow_ownership_transfer:
        Allow moves by owner even if it would result in an ownership transfer
        for the content being moved. This does not apply to copies.
    """

    __slots__ = [
        "_allow_shared_folder_value",
        "_allow_ownership_transfer_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        entries=None,
        autorename=None,
        allow_shared_folder=None,
        allow_ownership_transfer=None,
    ):
        super(RelocationBatchArg, self).__init__(entries, autorename)
        self._allow_shared_folder_value = bb.NOT_SET
        self._allow_ownership_transfer_value = bb.NOT_SET
        if allow_shared_folder is not None:
            self.allow_shared_folder = allow_shared_folder
        if allow_ownership_transfer is not None:
            self.allow_ownership_transfer = allow_ownership_transfer

    # Instance attribute type: bool (validator is set below)
    allow_shared_folder = bb.Attribute("allow_shared_folder")

    # Instance attribute type: bool (validator is set below)
    allow_ownership_transfer = bb.Attribute("allow_ownership_transfer")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchArg_validator = bv.Struct(RelocationBatchArg)


class RelocationError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar RelocationError.cant_copy_shared_folder:
        Shared folders can't be copied.
    :ivar RelocationError.cant_nest_shared_folder:
        Your move operation would result in nested shared folders.  This is not
        allowed.
    :ivar RelocationError.cant_move_folder_into_itself:
        You cannot move a folder into itself.
    :ivar RelocationError.too_many_files:
        The operation would involve more than 10,000 files and folders.
    :ivar RelocationError.duplicated_or_nested_paths:
        There are duplicated/nested paths among ``RelocationArg.from_path`` and
        ``RelocationArg.to_path``.
    :ivar RelocationError.cant_transfer_ownership:
        Your move operation would result in an ownership transfer. You may
        reissue the request with the field
        ``RelocationArg.allow_ownership_transfer`` to true.
    :ivar RelocationError.insufficient_quota:
        The current user does not have enough space to move or copy the files.
    :ivar RelocationError.internal_error:
        Something went wrong with the job on Dropbox's end. You'll need to
        verify that the action you were taking succeeded, and if not, try again.
        This should happen very rarely.
    :ivar RelocationError.cant_move_shared_folder:
        Can't move the shared folder to the given destination.
    :ivar RelocationError.cant_move_into_vault:
        Some content cannot be moved into Vault under certain circumstances, see
        detailed error.
    :vartype RelocationError.cant_move_into_vault: MoveIntoVaultError
    :ivar RelocationError.cant_move_into_family:
        Some content cannot be moved into the Family Room folder under certain
        circumstances, see detailed error.
    :vartype RelocationError.cant_move_into_family: MoveIntoFamilyError
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    cant_copy_shared_folder = None
    # Attribute is overwritten below the class definition
    cant_nest_shared_folder = None
    # Attribute is overwritten below the class definition
    cant_move_folder_into_itself = None
    # Attribute is overwritten below the class definition
    too_many_files = None
    # Attribute is overwritten below the class definition
    duplicated_or_nested_paths = None
    # Attribute is overwritten below the class definition
    cant_transfer_ownership = None
    # Attribute is overwritten below the class definition
    insufficient_quota = None
    # Attribute is overwritten below the class definition
    internal_error = None
    # Attribute is overwritten below the class definition
    cant_move_shared_folder = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def from_lookup(cls, val):
        """
        Create an instance of this class set to the ``from_lookup`` tag with
        value ``val``.

        :param LookupError val:
        :rtype: RelocationError
        """
        return cls("from_lookup", val)

    @classmethod
    def from_write(cls, val):
        """
        Create an instance of this class set to the ``from_write`` tag with
        value ``val``.

        :param WriteError val:
        :rtype: RelocationError
        """
        return cls("from_write", val)

    @classmethod
    def to(cls, val):
        """
        Create an instance of this class set to the ``to`` tag with value
        ``val``.

        :param WriteError val:
        :rtype: RelocationError
        """
        return cls("to", val)

    @classmethod
    def cant_move_into_vault(cls, val):
        """
        Create an instance of this class set to the ``cant_move_into_vault`` tag
        with value ``val``.

        :param MoveIntoVaultError val:
        :rtype: RelocationError
        """
        return cls("cant_move_into_vault", val)

    @classmethod
    def cant_move_into_family(cls, val):
        """
        Create an instance of this class set to the ``cant_move_into_family``
        tag with value ``val``.

        :param MoveIntoFamilyError val:
        :rtype: RelocationError
        """
        return cls("cant_move_into_family", val)

    def is_from_lookup(self):
        """
        Check if the union tag is ``from_lookup``.

        :rtype: bool
        """
        return self._tag == "from_lookup"

    def is_from_write(self):
        """
        Check if the union tag is ``from_write``.

        :rtype: bool
        """
        return self._tag == "from_write"

    def is_to(self):
        """
        Check if the union tag is ``to``.

        :rtype: bool
        """
        return self._tag == "to"

    def is_cant_copy_shared_folder(self):
        """
        Check if the union tag is ``cant_copy_shared_folder``.

        :rtype: bool
        """
        return self._tag == "cant_copy_shared_folder"

    def is_cant_nest_shared_folder(self):
        """
        Check if the union tag is ``cant_nest_shared_folder``.

        :rtype: bool
        """
        return self._tag == "cant_nest_shared_folder"

    def is_cant_move_folder_into_itself(self):
        """
        Check if the union tag is ``cant_move_folder_into_itself``.

        :rtype: bool
        """
        return self._tag == "cant_move_folder_into_itself"

    def is_too_many_files(self):
        """
        Check if the union tag is ``too_many_files``.

        :rtype: bool
        """
        return self._tag == "too_many_files"

    def is_duplicated_or_nested_paths(self):
        """
        Check if the union tag is ``duplicated_or_nested_paths``.

        :rtype: bool
        """
        return self._tag == "duplicated_or_nested_paths"

    def is_cant_transfer_ownership(self):
        """
        Check if the union tag is ``cant_transfer_ownership``.

        :rtype: bool
        """
        return self._tag == "cant_transfer_ownership"

    def is_insufficient_quota(self):
        """
        Check if the union tag is ``insufficient_quota``.

        :rtype: bool
        """
        return self._tag == "insufficient_quota"

    def is_internal_error(self):
        """
        Check if the union tag is ``internal_error``.

        :rtype: bool
        """
        return self._tag == "internal_error"

    def is_cant_move_shared_folder(self):
        """
        Check if the union tag is ``cant_move_shared_folder``.

        :rtype: bool
        """
        return self._tag == "cant_move_shared_folder"

    def is_cant_move_into_vault(self):
        """
        Check if the union tag is ``cant_move_into_vault``.

        :rtype: bool
        """
        return self._tag == "cant_move_into_vault"

    def is_cant_move_into_family(self):
        """
        Check if the union tag is ``cant_move_into_family``.

        :rtype: bool
        """
        return self._tag == "cant_move_into_family"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_from_lookup(self):
        """
        Only call this if :meth:`is_from_lookup` is true.

        :rtype: LookupError
        """
        if not self.is_from_lookup():
            raise AttributeError("tag 'from_lookup' not set")
        return self._value

    def get_from_write(self):
        """
        Only call this if :meth:`is_from_write` is true.

        :rtype: WriteError
        """
        if not self.is_from_write():
            raise AttributeError("tag 'from_write' not set")
        return self._value

    def get_to(self):
        """
        Only call this if :meth:`is_to` is true.

        :rtype: WriteError
        """
        if not self.is_to():
            raise AttributeError("tag 'to' not set")
        return self._value

    def get_cant_move_into_vault(self):
        """
        Some content cannot be moved into Vault under certain circumstances, see
        detailed error.

        Only call this if :meth:`is_cant_move_into_vault` is true.

        :rtype: MoveIntoVaultError
        """
        if not self.is_cant_move_into_vault():
            raise AttributeError("tag 'cant_move_into_vault' not set")
        return self._value

    def get_cant_move_into_family(self):
        """
        Some content cannot be moved into the Family Room folder under certain
        circumstances, see detailed error.

        Only call this if :meth:`is_cant_move_into_family` is true.

        :rtype: MoveIntoFamilyError
        """
        if not self.is_cant_move_into_family():
            raise AttributeError("tag 'cant_move_into_family' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationError_validator = bv.Union(RelocationError)


class RelocationBatchError(RelocationError):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar RelocationBatchError.too_many_write_operations:
        There are too many write operations in user's Dropbox. Please retry this
        request.
    """

    # Attribute is overwritten below the class definition
    too_many_write_operations = None

    def is_too_many_write_operations(self):
        """
        Check if the union tag is ``too_many_write_operations``.

        :rtype: bool
        """
        return self._tag == "too_many_write_operations"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchError_validator = bv.Union(RelocationBatchError)


class RelocationBatchErrorEntry(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar RelocationBatchErrorEntry.relocation_error:
        User errors that retry won't help.
    :vartype RelocationBatchErrorEntry.relocation_error: RelocationError
    :ivar RelocationBatchErrorEntry.internal_error:
        Something went wrong with the job on Dropbox's end. You'll need to
        verify that the action you were taking succeeded, and if not, try again.
        This should happen very rarely.
    :ivar RelocationBatchErrorEntry.too_many_write_operations:
        There are too many write operations in user's Dropbox. Please retry this
        request.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    internal_error = None
    # Attribute is overwritten below the class definition
    too_many_write_operations = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def relocation_error(cls, val):
        """
        Create an instance of this class set to the ``relocation_error`` tag
        with value ``val``.

        :param RelocationError val:
        :rtype: RelocationBatchErrorEntry
        """
        return cls("relocation_error", val)

    def is_relocation_error(self):
        """
        Check if the union tag is ``relocation_error``.

        :rtype: bool
        """
        return self._tag == "relocation_error"

    def is_internal_error(self):
        """
        Check if the union tag is ``internal_error``.

        :rtype: bool
        """
        return self._tag == "internal_error"

    def is_too_many_write_operations(self):
        """
        Check if the union tag is ``too_many_write_operations``.

        :rtype: bool
        """
        return self._tag == "too_many_write_operations"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_relocation_error(self):
        """
        User errors that retry won't help.

        Only call this if :meth:`is_relocation_error` is true.

        :rtype: RelocationError
        """
        if not self.is_relocation_error():
            raise AttributeError("tag 'relocation_error' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchErrorEntry, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchErrorEntry_validator = bv.Union(RelocationBatchErrorEntry)


class RelocationBatchJobStatus(async_.PollResultBase):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar RelocationBatchJobStatus.complete:
        The copy or move batch job has finished.
    :vartype RelocationBatchJobStatus.complete: RelocationBatchResult
    :ivar RelocationBatchJobStatus.failed:
        The copy or move batch job has failed with exception.
    :vartype RelocationBatchJobStatus.failed: RelocationBatchError
    """

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param RelocationBatchResult val:
        :rtype: RelocationBatchJobStatus
        """
        return cls("complete", val)

    @classmethod
    def failed(cls, val):
        """
        Create an instance of this class set to the ``failed`` tag with value
        ``val``.

        :param RelocationBatchError val:
        :rtype: RelocationBatchJobStatus
        """
        return cls("failed", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def is_failed(self):
        """
        Check if the union tag is ``failed``.

        :rtype: bool
        """
        return self._tag == "failed"

    def get_complete(self):
        """
        The copy or move batch job has finished.

        Only call this if :meth:`is_complete` is true.

        :rtype: RelocationBatchResult
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def get_failed(self):
        """
        The copy or move batch job has failed with exception.

        Only call this if :meth:`is_failed` is true.

        :rtype: RelocationBatchError
        """
        if not self.is_failed():
            raise AttributeError("tag 'failed' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchJobStatus, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchJobStatus_validator = bv.Union(RelocationBatchJobStatus)


class RelocationBatchLaunch(async_.LaunchResultBase):
    """
    Result returned by :meth:`dropbox.dropbox_client.Dropbox.files_copy_batch`
    or :meth:`dropbox.dropbox_client.Dropbox.files_move_batch` that may either
    launch an asynchronous job or complete synchronously.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param RelocationBatchResult val:
        :rtype: RelocationBatchLaunch
        """
        return cls("complete", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_complete(self):
        """
        Only call this if :meth:`is_complete` is true.

        :rtype: RelocationBatchResult
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchLaunch, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchLaunch_validator = bv.Union(RelocationBatchLaunch)


class RelocationBatchResult(FileOpsResult):
    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        super(RelocationBatchResult, self).__init__()
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [RelocationBatchResultData] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchResult_validator = bv.Struct(RelocationBatchResult)


class RelocationBatchResultData(bb.Struct):
    """
    :ivar RelocationBatchResultData.metadata:
        Metadata of the relocated object.
    """

    __slots__ = [
        "_metadata_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None):
        self._metadata_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata

    # Instance attribute type: Metadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchResultData, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchResultData_validator = bv.Struct(RelocationBatchResultData)


class RelocationBatchResultEntry(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def success(cls, val):
        """
        Create an instance of this class set to the ``success`` tag with value
        ``val``.

        :param Metadata val:
        :rtype: RelocationBatchResultEntry
        """
        return cls("success", val)

    @classmethod
    def failure(cls, val):
        """
        Create an instance of this class set to the ``failure`` tag with value
        ``val``.

        :param RelocationBatchErrorEntry val:
        :rtype: RelocationBatchResultEntry
        """
        return cls("failure", val)

    def is_success(self):
        """
        Check if the union tag is ``success``.

        :rtype: bool
        """
        return self._tag == "success"

    def is_failure(self):
        """
        Check if the union tag is ``failure``.

        :rtype: bool
        """
        return self._tag == "failure"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_success(self):
        """
        Only call this if :meth:`is_success` is true.

        :rtype: Metadata
        """
        if not self.is_success():
            raise AttributeError("tag 'success' not set")
        return self._value

    def get_failure(self):
        """
        Only call this if :meth:`is_failure` is true.

        :rtype: RelocationBatchErrorEntry
        """
        if not self.is_failure():
            raise AttributeError("tag 'failure' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchResultEntry, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchResultEntry_validator = bv.Union(RelocationBatchResultEntry)


class RelocationBatchV2JobStatus(async_.PollResultBase):
    """
    Result returned by
    :meth:`dropbox.dropbox_client.Dropbox.files_copy_batch_check` or
    :meth:`dropbox.dropbox_client.Dropbox.files_move_batch_check` that may
    either be in progress or completed with result for each entry.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar RelocationBatchV2JobStatus.complete:
        The copy or move batch job has finished.
    :vartype RelocationBatchV2JobStatus.complete: RelocationBatchV2Result
    """

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param RelocationBatchV2Result val:
        :rtype: RelocationBatchV2JobStatus
        """
        return cls("complete", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def get_complete(self):
        """
        The copy or move batch job has finished.

        Only call this if :meth:`is_complete` is true.

        :rtype: RelocationBatchV2Result
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchV2JobStatus, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchV2JobStatus_validator = bv.Union(RelocationBatchV2JobStatus)


class RelocationBatchV2Launch(async_.LaunchResultBase):
    """
    Result returned by :meth:`dropbox.dropbox_client.Dropbox.files_copy_batch`
    or :meth:`dropbox.dropbox_client.Dropbox.files_move_batch` that may either
    launch an asynchronous job or complete synchronously.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param RelocationBatchV2Result val:
        :rtype: RelocationBatchV2Launch
        """
        return cls("complete", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def get_complete(self):
        """
        Only call this if :meth:`is_complete` is true.

        :rtype: RelocationBatchV2Result
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchV2Launch, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchV2Launch_validator = bv.Union(RelocationBatchV2Launch)


class RelocationBatchV2Result(FileOpsResult):
    """
    :ivar RelocationBatchV2Result.entries:
        Each entry in CopyBatchArg.entries or ``MoveBatchArg.entries`` will
        appear at the same position inside ``RelocationBatchV2Result.entries``.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        super(RelocationBatchV2Result, self).__init__()
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [RelocationBatchResultEntry] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationBatchV2Result, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationBatchV2Result_validator = bv.Struct(RelocationBatchV2Result)


class RelocationResult(FileOpsResult):
    """
    :ivar RelocationResult.metadata:
        Metadata of the relocated object.
    """

    __slots__ = [
        "_metadata_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None):
        super(RelocationResult, self).__init__()
        self._metadata_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata

    # Instance attribute type: Metadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RelocationResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RelocationResult_validator = bv.Struct(RelocationResult)


class RemoveTagArg(bb.Struct):
    """
    :ivar RemoveTagArg.path:
        Path to the item to tag.
    :ivar RemoveTagArg.tag_text:
        The tag to remove. Will be automatically converted to lowercase letters.
    """

    __slots__ = [
        "_path_value",
        "_tag_text_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, tag_text=None):
        self._path_value = bb.NOT_SET
        self._tag_text_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if tag_text is not None:
            self.tag_text = tag_text

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: str (validator is set below)
    tag_text = bb.Attribute("tag_text")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RemoveTagArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RemoveTagArg_validator = bv.Struct(RemoveTagArg)


class RemoveTagError(BaseTagError):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar RemoveTagError.tag_not_present:
        That tag doesn't exist at this path.
    """

    # Attribute is overwritten below the class definition
    tag_not_present = None

    def is_tag_not_present(self):
        """
        Check if the union tag is ``tag_not_present``.

        :rtype: bool
        """
        return self._tag == "tag_not_present"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RemoveTagError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RemoveTagError_validator = bv.Union(RemoveTagError)


class RestoreArg(bb.Struct):
    """
    :ivar RestoreArg.path:
        The path to save the restored file.
    :ivar RestoreArg.rev:
        The revision to restore.
    """

    __slots__ = [
        "_path_value",
        "_rev_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, rev=None):
        self._path_value = bb.NOT_SET
        self._rev_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if rev is not None:
            self.rev = rev

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: str (validator is set below)
    rev = bb.Attribute("rev")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RestoreArg, self)._process_custom_annotations(annotation_type, field_path, processor)


RestoreArg_validator = bv.Struct(RestoreArg)


class RestoreError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar RestoreError.path_lookup:
        An error occurs when downloading metadata for the file.
    :vartype RestoreError.path_lookup: LookupError
    :ivar RestoreError.path_write:
        An error occurs when trying to restore the file to that path.
    :vartype RestoreError.path_write: WriteError
    :ivar RestoreError.invalid_revision:
        The revision is invalid. It may not exist or may point to a deleted
        file.
    :ivar RestoreError.in_progress:
        The restore is currently executing, but has not yet completed.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    invalid_revision = None
    # Attribute is overwritten below the class definition
    in_progress = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path_lookup(cls, val):
        """
        Create an instance of this class set to the ``path_lookup`` tag with
        value ``val``.

        :param LookupError val:
        :rtype: RestoreError
        """
        return cls("path_lookup", val)

    @classmethod
    def path_write(cls, val):
        """
        Create an instance of this class set to the ``path_write`` tag with
        value ``val``.

        :param WriteError val:
        :rtype: RestoreError
        """
        return cls("path_write", val)

    def is_path_lookup(self):
        """
        Check if the union tag is ``path_lookup``.

        :rtype: bool
        """
        return self._tag == "path_lookup"

    def is_path_write(self):
        """
        Check if the union tag is ``path_write``.

        :rtype: bool
        """
        return self._tag == "path_write"

    def is_invalid_revision(self):
        """
        Check if the union tag is ``invalid_revision``.

        :rtype: bool
        """
        return self._tag == "invalid_revision"

    def is_in_progress(self):
        """
        Check if the union tag is ``in_progress``.

        :rtype: bool
        """
        return self._tag == "in_progress"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path_lookup(self):
        """
        An error occurs when downloading metadata for the file.

        Only call this if :meth:`is_path_lookup` is true.

        :rtype: LookupError
        """
        if not self.is_path_lookup():
            raise AttributeError("tag 'path_lookup' not set")
        return self._value

    def get_path_write(self):
        """
        An error occurs when trying to restore the file to that path.

        Only call this if :meth:`is_path_write` is true.

        :rtype: WriteError
        """
        if not self.is_path_write():
            raise AttributeError("tag 'path_write' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(RestoreError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


RestoreError_validator = bv.Union(RestoreError)


class SaveCopyReferenceArg(bb.Struct):
    """
    :ivar SaveCopyReferenceArg.copy_reference:
        A copy reference returned by
        :meth:`dropbox.dropbox_client.Dropbox.files_copy_reference_get`.
    :ivar SaveCopyReferenceArg.path:
        Path in the user's Dropbox that is the destination.
    """

    __slots__ = [
        "_copy_reference_value",
        "_path_value",
    ]

    _has_required_fields = True

    def __init__(self, copy_reference=None, path=None):
        self._copy_reference_value = bb.NOT_SET
        self._path_value = bb.NOT_SET
        if copy_reference is not None:
            self.copy_reference = copy_reference
        if path is not None:
            self.path = path

    # Instance attribute type: str (validator is set below)
    copy_reference = bb.Attribute("copy_reference")

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SaveCopyReferenceArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SaveCopyReferenceArg_validator = bv.Struct(SaveCopyReferenceArg)


class SaveCopyReferenceError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SaveCopyReferenceError.invalid_copy_reference:
        The copy reference is invalid.
    :ivar SaveCopyReferenceError.no_permission:
        You don't have permission to save the given copy reference. Please make
        sure this app is same app which created the copy reference and the
        source user is still linked to the app.
    :ivar SaveCopyReferenceError.not_found:
        The file referenced by the copy reference cannot be found.
    :ivar SaveCopyReferenceError.too_many_files:
        The operation would involve more than 10,000 files and folders.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    invalid_copy_reference = None
    # Attribute is overwritten below the class definition
    no_permission = None
    # Attribute is overwritten below the class definition
    not_found = None
    # Attribute is overwritten below the class definition
    too_many_files = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param WriteError val:
        :rtype: SaveCopyReferenceError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_invalid_copy_reference(self):
        """
        Check if the union tag is ``invalid_copy_reference``.

        :rtype: bool
        """
        return self._tag == "invalid_copy_reference"

    def is_no_permission(self):
        """
        Check if the union tag is ``no_permission``.

        :rtype: bool
        """
        return self._tag == "no_permission"

    def is_not_found(self):
        """
        Check if the union tag is ``not_found``.

        :rtype: bool
        """
        return self._tag == "not_found"

    def is_too_many_files(self):
        """
        Check if the union tag is ``too_many_files``.

        :rtype: bool
        """
        return self._tag == "too_many_files"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: WriteError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SaveCopyReferenceError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SaveCopyReferenceError_validator = bv.Union(SaveCopyReferenceError)


class SaveCopyReferenceResult(bb.Struct):
    """
    :ivar SaveCopyReferenceResult.metadata:
        The metadata of the saved file or folder in the user's Dropbox.
    """

    __slots__ = [
        "_metadata_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None):
        self._metadata_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata

    # Instance attribute type: Metadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SaveCopyReferenceResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SaveCopyReferenceResult_validator = bv.Struct(SaveCopyReferenceResult)


class SaveUrlArg(bb.Struct):
    """
    :ivar SaveUrlArg.path:
        The path in Dropbox where the URL will be saved to.
    :ivar SaveUrlArg.url:
        The URL to be saved.
    """

    __slots__ = [
        "_path_value",
        "_url_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, url=None):
        self._path_value = bb.NOT_SET
        self._url_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if url is not None:
            self.url = url

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: str (validator is set below)
    url = bb.Attribute("url")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SaveUrlArg, self)._process_custom_annotations(annotation_type, field_path, processor)


SaveUrlArg_validator = bv.Struct(SaveUrlArg)


class SaveUrlError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SaveUrlError.download_failed:
        Failed downloading the given URL. The URL may be password-protected and
        the password provided was incorrect, or the link may be disabled.
    :ivar SaveUrlError.invalid_url:
        The given URL is invalid.
    :ivar SaveUrlError.not_found:
        The file where the URL is saved to no longer exists.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    download_failed = None
    # Attribute is overwritten below the class definition
    invalid_url = None
    # Attribute is overwritten below the class definition
    not_found = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param WriteError val:
        :rtype: SaveUrlError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_download_failed(self):
        """
        Check if the union tag is ``download_failed``.

        :rtype: bool
        """
        return self._tag == "download_failed"

    def is_invalid_url(self):
        """
        Check if the union tag is ``invalid_url``.

        :rtype: bool
        """
        return self._tag == "invalid_url"

    def is_not_found(self):
        """
        Check if the union tag is ``not_found``.

        :rtype: bool
        """
        return self._tag == "not_found"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: WriteError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SaveUrlError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SaveUrlError_validator = bv.Union(SaveUrlError)


class SaveUrlJobStatus(async_.PollResultBase):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SaveUrlJobStatus.complete:
        Metadata of the file where the URL is saved to.
    :vartype SaveUrlJobStatus.complete: FileMetadata
    """

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param FileMetadata val:
        :rtype: SaveUrlJobStatus
        """
        return cls("complete", val)

    @classmethod
    def failed(cls, val):
        """
        Create an instance of this class set to the ``failed`` tag with value
        ``val``.

        :param SaveUrlError val:
        :rtype: SaveUrlJobStatus
        """
        return cls("failed", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def is_failed(self):
        """
        Check if the union tag is ``failed``.

        :rtype: bool
        """
        return self._tag == "failed"

    def get_complete(self):
        """
        Metadata of the file where the URL is saved to.

        Only call this if :meth:`is_complete` is true.

        :rtype: FileMetadata
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def get_failed(self):
        """
        Only call this if :meth:`is_failed` is true.

        :rtype: SaveUrlError
        """
        if not self.is_failed():
            raise AttributeError("tag 'failed' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SaveUrlJobStatus, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SaveUrlJobStatus_validator = bv.Union(SaveUrlJobStatus)


class SaveUrlResult(async_.LaunchResultBase):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SaveUrlResult.complete:
        Metadata of the file where the URL is saved to.
    :vartype SaveUrlResult.complete: FileMetadata
    """

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param FileMetadata val:
        :rtype: SaveUrlResult
        """
        return cls("complete", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def get_complete(self):
        """
        Metadata of the file where the URL is saved to.

        Only call this if :meth:`is_complete` is true.

        :rtype: FileMetadata
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SaveUrlResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SaveUrlResult_validator = bv.Union(SaveUrlResult)


class SearchArg(bb.Struct):
    """
    :ivar SearchArg.path:
        The path in the user's Dropbox to search. Should probably be a folder.
    :ivar SearchArg.query:
        The string to search for. Query string may be rewritten to improve
        relevance of results. The string is split on spaces into multiple
        tokens. For file name searching, the last token is used for prefix
        matching (i.e. "bat c" matches "bat cave" but not "batman car").
    :ivar SearchArg.start:
        The starting index within the search results (used for paging).
    :ivar SearchArg.max_results:
        The maximum number of search results to return.
    :ivar SearchArg.mode:
        The search mode (filename, filename_and_content, or deleted_filename).
        Note that searching file content is only available for Dropbox Business
        accounts.
    """

    __slots__ = [
        "_path_value",
        "_query_value",
        "_start_value",
        "_max_results_value",
        "_mode_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None, query=None, start=None, max_results=None, mode=None):
        self._path_value = bb.NOT_SET
        self._query_value = bb.NOT_SET
        self._start_value = bb.NOT_SET
        self._max_results_value = bb.NOT_SET
        self._mode_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if query is not None:
            self.query = query
        if start is not None:
            self.start = start
        if max_results is not None:
            self.max_results = max_results
        if mode is not None:
            self.mode = mode

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: str (validator is set below)
    query = bb.Attribute("query")

    # Instance attribute type: int (validator is set below)
    start = bb.Attribute("start")

    # Instance attribute type: int (validator is set below)
    max_results = bb.Attribute("max_results")

    # Instance attribute type: SearchMode (validator is set below)
    mode = bb.Attribute("mode", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchArg, self)._process_custom_annotations(annotation_type, field_path, processor)


SearchArg_validator = bv.Struct(SearchArg)


class SearchError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SearchError.internal_error:
        Something went wrong, please try again.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    internal_error = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: SearchError
        """
        return cls("path", val)

    @classmethod
    def invalid_argument(cls, val):
        """
        Create an instance of this class set to the ``invalid_argument`` tag
        with value ``val``.

        :param str val:
        :rtype: SearchError
        """
        return cls("invalid_argument", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_invalid_argument(self):
        """
        Check if the union tag is ``invalid_argument``.

        :rtype: bool
        """
        return self._tag == "invalid_argument"

    def is_internal_error(self):
        """
        Check if the union tag is ``internal_error``.

        :rtype: bool
        """
        return self._tag == "internal_error"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def get_invalid_argument(self):
        """
        Only call this if :meth:`is_invalid_argument` is true.

        :rtype: str
        """
        if not self.is_invalid_argument():
            raise AttributeError("tag 'invalid_argument' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchError, self)._process_custom_annotations(annotation_type, field_path, processor)


SearchError_validator = bv.Union(SearchError)


class SearchMatch(bb.Struct):
    """
    :ivar SearchMatch.match_type:
        The type of the match.
    :ivar SearchMatch.metadata:
        The metadata for the matched file or folder.
    """

    __slots__ = [
        "_match_type_value",
        "_metadata_value",
    ]

    _has_required_fields = True

    def __init__(self, match_type=None, metadata=None):
        self._match_type_value = bb.NOT_SET
        self._metadata_value = bb.NOT_SET
        if match_type is not None:
            self.match_type = match_type
        if metadata is not None:
            self.metadata = metadata

    # Instance attribute type: SearchMatchType (validator is set below)
    match_type = bb.Attribute("match_type", user_defined=True)

    # Instance attribute type: Metadata (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchMatch, self)._process_custom_annotations(annotation_type, field_path, processor)


SearchMatch_validator = bv.Struct(SearchMatch)


class SearchMatchFieldOptions(bb.Struct):
    """
    :ivar SearchMatchFieldOptions.include_highlights:
        Whether to include highlight span from file title.
    """

    __slots__ = [
        "_include_highlights_value",
    ]

    _has_required_fields = False

    def __init__(self, include_highlights=None):
        self._include_highlights_value = bb.NOT_SET
        if include_highlights is not None:
            self.include_highlights = include_highlights

    # Instance attribute type: bool (validator is set below)
    include_highlights = bb.Attribute("include_highlights")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchMatchFieldOptions, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SearchMatchFieldOptions_validator = bv.Struct(SearchMatchFieldOptions)


class SearchMatchType(bb.Union):
    """
    Indicates what type of match was found for a given item.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SearchMatchType.filename:
        This item was matched on its file or folder name.
    :ivar SearchMatchType.content:
        This item was matched based on its file contents.
    :ivar SearchMatchType.both:
        This item was matched based on both its contents and its file name.
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    filename = None
    # Attribute is overwritten below the class definition
    content = None
    # Attribute is overwritten below the class definition
    both = None

    def is_filename(self):
        """
        Check if the union tag is ``filename``.

        :rtype: bool
        """
        return self._tag == "filename"

    def is_content(self):
        """
        Check if the union tag is ``content``.

        :rtype: bool
        """
        return self._tag == "content"

    def is_both(self):
        """
        Check if the union tag is ``both``.

        :rtype: bool
        """
        return self._tag == "both"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchMatchType, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SearchMatchType_validator = bv.Union(SearchMatchType)


class SearchMatchTypeV2(bb.Union):
    """
    Indicates what type of match was found for a given item.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SearchMatchTypeV2.filename:
        This item was matched on its file or folder name.
    :ivar SearchMatchTypeV2.file_content:
        This item was matched based on its file contents.
    :ivar SearchMatchTypeV2.filename_and_content:
        This item was matched based on both its contents and its file name.
    :ivar SearchMatchTypeV2.image_content:
        This item was matched on image content.
    :ivar SearchMatchTypeV2.metadata:
        This item was matched based on its metadata.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    filename = None
    # Attribute is overwritten below the class definition
    file_content = None
    # Attribute is overwritten below the class definition
    filename_and_content = None
    # Attribute is overwritten below the class definition
    image_content = None
    # Attribute is overwritten below the class definition
    metadata = None
    # Attribute is overwritten below the class definition
    other = None

    def is_filename(self):
        """
        Check if the union tag is ``filename``.

        :rtype: bool
        """
        return self._tag == "filename"

    def is_file_content(self):
        """
        Check if the union tag is ``file_content``.

        :rtype: bool
        """
        return self._tag == "file_content"

    def is_filename_and_content(self):
        """
        Check if the union tag is ``filename_and_content``.

        :rtype: bool
        """
        return self._tag == "filename_and_content"

    def is_image_content(self):
        """
        Check if the union tag is ``image_content``.

        :rtype: bool
        """
        return self._tag == "image_content"

    def is_metadata(self):
        """
        Check if the union tag is ``metadata``.

        :rtype: bool
        """
        return self._tag == "metadata"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchMatchTypeV2, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SearchMatchTypeV2_validator = bv.Union(SearchMatchTypeV2)


class SearchMatchV2(bb.Struct):
    """
    :ivar SearchMatchV2.metadata:
        The metadata for the matched file or folder.
    :ivar SearchMatchV2.match_type:
        The type of the match.
    :ivar SearchMatchV2.highlight_spans:
        The list of HighlightSpan determines which parts of the file title
        should be highlighted.
    """

    __slots__ = [
        "_metadata_value",
        "_match_type_value",
        "_highlight_spans_value",
    ]

    _has_required_fields = True

    def __init__(self, metadata=None, match_type=None, highlight_spans=None):
        self._metadata_value = bb.NOT_SET
        self._match_type_value = bb.NOT_SET
        self._highlight_spans_value = bb.NOT_SET
        if metadata is not None:
            self.metadata = metadata
        if match_type is not None:
            self.match_type = match_type
        if highlight_spans is not None:
            self.highlight_spans = highlight_spans

    # Instance attribute type: MetadataV2 (validator is set below)
    metadata = bb.Attribute("metadata", user_defined=True)

    # Instance attribute type: SearchMatchTypeV2 (validator is set below)
    match_type = bb.Attribute("match_type", nullable=True, user_defined=True)

    # Instance attribute type: list of [HighlightSpan] (validator is set below)
    highlight_spans = bb.Attribute("highlight_spans", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchMatchV2, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SearchMatchV2_validator = bv.Struct(SearchMatchV2)


class SearchMode(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SearchMode.filename:
        Search file and folder names.
    :ivar SearchMode.filename_and_content:
        Search file and folder names as well as file contents.
    :ivar SearchMode.deleted_filename:
        Search for deleted file and folder names.
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    filename = None
    # Attribute is overwritten below the class definition
    filename_and_content = None
    # Attribute is overwritten below the class definition
    deleted_filename = None

    def is_filename(self):
        """
        Check if the union tag is ``filename``.

        :rtype: bool
        """
        return self._tag == "filename"

    def is_filename_and_content(self):
        """
        Check if the union tag is ``filename_and_content``.

        :rtype: bool
        """
        return self._tag == "filename_and_content"

    def is_deleted_filename(self):
        """
        Check if the union tag is ``deleted_filename``.

        :rtype: bool
        """
        return self._tag == "deleted_filename"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchMode, self)._process_custom_annotations(annotation_type, field_path, processor)


SearchMode_validator = bv.Union(SearchMode)


class SearchOptions(bb.Struct):
    """
    :ivar SearchOptions.path:
        Scopes the search to a path in the user's Dropbox. Searches the entire
        Dropbox if not specified.
    :ivar SearchOptions.max_results:
        The maximum number of search results to return.
    :ivar SearchOptions.order_by:
        Specified property of the order of search results. By default, results
        are sorted by relevance.
    :ivar SearchOptions.file_status:
        Restricts search to the given file status.
    :ivar SearchOptions.filename_only:
        Restricts search to only match on filenames.
    :ivar SearchOptions.file_extensions:
        Restricts search to only the extensions specified. Only supported for
        active file search.
    :ivar SearchOptions.file_categories:
        Restricts search to only the file categories specified. Only supported
        for active file search.
    :ivar SearchOptions.account_id:
        Restricts results to the given account id.
    """

    __slots__ = [
        "_path_value",
        "_max_results_value",
        "_order_by_value",
        "_file_status_value",
        "_filename_only_value",
        "_file_extensions_value",
        "_file_categories_value",
        "_account_id_value",
    ]

    _has_required_fields = False

    def __init__(
        self,
        path=None,
        max_results=None,
        order_by=None,
        file_status=None,
        filename_only=None,
        file_extensions=None,
        file_categories=None,
        account_id=None,
    ):
        self._path_value = bb.NOT_SET
        self._max_results_value = bb.NOT_SET
        self._order_by_value = bb.NOT_SET
        self._file_status_value = bb.NOT_SET
        self._filename_only_value = bb.NOT_SET
        self._file_extensions_value = bb.NOT_SET
        self._file_categories_value = bb.NOT_SET
        self._account_id_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if max_results is not None:
            self.max_results = max_results
        if order_by is not None:
            self.order_by = order_by
        if file_status is not None:
            self.file_status = file_status
        if filename_only is not None:
            self.filename_only = filename_only
        if file_extensions is not None:
            self.file_extensions = file_extensions
        if file_categories is not None:
            self.file_categories = file_categories
        if account_id is not None:
            self.account_id = account_id

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path", nullable=True)

    # Instance attribute type: int (validator is set below)
    max_results = bb.Attribute("max_results")

    # Instance attribute type: SearchOrderBy (validator is set below)
    order_by = bb.Attribute("order_by", nullable=True, user_defined=True)

    # Instance attribute type: FileStatus (validator is set below)
    file_status = bb.Attribute("file_status", user_defined=True)

    # Instance attribute type: bool (validator is set below)
    filename_only = bb.Attribute("filename_only")

    # Instance attribute type: list of [str] (validator is set below)
    file_extensions = bb.Attribute("file_extensions", nullable=True)

    # Instance attribute type: list of [FileCategory] (validator is set below)
    file_categories = bb.Attribute("file_categories", nullable=True)

    # Instance attribute type: str (validator is set below)
    account_id = bb.Attribute("account_id", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchOptions, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SearchOptions_validator = bv.Struct(SearchOptions)


class SearchOrderBy(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    relevance = None
    # Attribute is overwritten below the class definition
    last_modified_time = None
    # Attribute is overwritten below the class definition
    other = None

    def is_relevance(self):
        """
        Check if the union tag is ``relevance``.

        :rtype: bool
        """
        return self._tag == "relevance"

    def is_last_modified_time(self):
        """
        Check if the union tag is ``last_modified_time``.

        :rtype: bool
        """
        return self._tag == "last_modified_time"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchOrderBy, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SearchOrderBy_validator = bv.Union(SearchOrderBy)


class SearchResult(bb.Struct):
    """
    :ivar SearchResult.matches:
        A list (possibly empty) of matches for the query.
    :ivar SearchResult.more:
        Used for paging. If true, indicates there is another page of results
        available that can be fetched by calling
        :meth:`dropbox.dropbox_client.Dropbox.files_search` again.
    :ivar SearchResult.start:
        Used for paging. Value to set the start argument to when calling
        :meth:`dropbox.dropbox_client.Dropbox.files_search` to fetch the next
        page of results.
    """

    __slots__ = [
        "_matches_value",
        "_more_value",
        "_start_value",
    ]

    _has_required_fields = True

    def __init__(self, matches=None, more=None, start=None):
        self._matches_value = bb.NOT_SET
        self._more_value = bb.NOT_SET
        self._start_value = bb.NOT_SET
        if matches is not None:
            self.matches = matches
        if more is not None:
            self.more = more
        if start is not None:
            self.start = start

    # Instance attribute type: list of [SearchMatch] (validator is set below)
    matches = bb.Attribute("matches")

    # Instance attribute type: bool (validator is set below)
    more = bb.Attribute("more")

    # Instance attribute type: int (validator is set below)
    start = bb.Attribute("start")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SearchResult_validator = bv.Struct(SearchResult)


class SearchV2Arg(bb.Struct):
    """
    :ivar SearchV2Arg.query:
        The string to search for. May match across multiple fields based on the
        request arguments.
    :ivar SearchV2Arg.options:
        Options for more targeted search results.
    :ivar SearchV2Arg.match_field_options:
        Options for search results match fields.
    :ivar SearchV2Arg.include_highlights:
        Field is deprecated. Deprecated and moved this option to
        SearchMatchFieldOptions.
    """

    __slots__ = [
        "_query_value",
        "_options_value",
        "_match_field_options_value",
        "_include_highlights_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        query=None,
        options=None,
        match_field_options=None,
        include_highlights=None,
    ):
        self._query_value = bb.NOT_SET
        self._options_value = bb.NOT_SET
        self._match_field_options_value = bb.NOT_SET
        self._include_highlights_value = bb.NOT_SET
        if query is not None:
            self.query = query
        if options is not None:
            self.options = options
        if match_field_options is not None:
            self.match_field_options = match_field_options
        if include_highlights is not None:
            self.include_highlights = include_highlights

    # Instance attribute type: str (validator is set below)
    query = bb.Attribute("query")

    # Instance attribute type: SearchOptions (validator is set below)
    options = bb.Attribute("options", nullable=True, user_defined=True)

    # Instance attribute type: SearchMatchFieldOptions (validator is set below)
    match_field_options = bb.Attribute("match_field_options", nullable=True, user_defined=True)

    # Instance attribute type: bool (validator is set below)
    include_highlights = bb.Attribute("include_highlights", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchV2Arg, self)._process_custom_annotations(annotation_type, field_path, processor)


SearchV2Arg_validator = bv.Struct(SearchV2Arg)


class SearchV2ContinueArg(bb.Struct):
    """
    :ivar SearchV2ContinueArg.cursor:
        The cursor returned by your last call to
        :meth:`dropbox.dropbox_client.Dropbox.files_search`. Used to fetch the
        next page of results.
    """

    __slots__ = [
        "_cursor_value",
    ]

    _has_required_fields = True

    def __init__(self, cursor=None):
        self._cursor_value = bb.NOT_SET
        if cursor is not None:
            self.cursor = cursor

    # Instance attribute type: str (validator is set below)
    cursor = bb.Attribute("cursor")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchV2ContinueArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SearchV2ContinueArg_validator = bv.Struct(SearchV2ContinueArg)


class SearchV2Result(bb.Struct):
    """
    :ivar SearchV2Result.matches:
        A list (possibly empty) of matches for the query.
    :ivar SearchV2Result.has_more:
        Used for paging. If true, indicates there is another page of results
        available that can be fetched by calling
        :meth:`dropbox.dropbox_client.Dropbox.files_search_continue` with the
        cursor.
    :ivar SearchV2Result.cursor:
        Pass the cursor into
        :meth:`dropbox.dropbox_client.Dropbox.files_search_continue` to fetch
        the next page of results.
    """

    __slots__ = [
        "_matches_value",
        "_has_more_value",
        "_cursor_value",
    ]

    _has_required_fields = True

    def __init__(self, matches=None, has_more=None, cursor=None):
        self._matches_value = bb.NOT_SET
        self._has_more_value = bb.NOT_SET
        self._cursor_value = bb.NOT_SET
        if matches is not None:
            self.matches = matches
        if has_more is not None:
            self.has_more = has_more
        if cursor is not None:
            self.cursor = cursor

    # Instance attribute type: list of [SearchMatchV2] (validator is set below)
    matches = bb.Attribute("matches")

    # Instance attribute type: bool (validator is set below)
    has_more = bb.Attribute("has_more")

    # Instance attribute type: str (validator is set below)
    cursor = bb.Attribute("cursor", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SearchV2Result, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SearchV2Result_validator = bv.Struct(SearchV2Result)


class SharedLink(bb.Struct):
    """
    :ivar SharedLink.url:
        Shared link url.
    :ivar SharedLink.password:
        Password for the shared link.
    """

    __slots__ = [
        "_url_value",
        "_password_value",
    ]

    _has_required_fields = True

    def __init__(self, url=None, password=None):
        self._url_value = bb.NOT_SET
        self._password_value = bb.NOT_SET
        if url is not None:
            self.url = url
        if password is not None:
            self.password = password

    # Instance attribute type: str (validator is set below)
    url = bb.Attribute("url")

    # Instance attribute type: str (validator is set below)
    password = bb.Attribute("password", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SharedLink, self)._process_custom_annotations(annotation_type, field_path, processor)


SharedLink_validator = bv.Struct(SharedLink)


class SharedLinkFileInfo(bb.Struct):
    """
    :ivar SharedLinkFileInfo.url:
        The shared link corresponding to either a file or shared link to a
        folder. If it is for a folder shared link, we use the path param to
        determine for which file in the folder the view is for.
    :ivar SharedLinkFileInfo.path:
        The path corresponding to a file in a shared link to a folder. Required
        for shared links to folders.
    :ivar SharedLinkFileInfo.password:
        Password for the shared link. Required for password-protected shared
        links to files unless it can be read from a cookie.
    """

    __slots__ = [
        "_url_value",
        "_path_value",
        "_password_value",
    ]

    _has_required_fields = True

    def __init__(self, url=None, path=None, password=None):
        self._url_value = bb.NOT_SET
        self._path_value = bb.NOT_SET
        self._password_value = bb.NOT_SET
        if url is not None:
            self.url = url
        if path is not None:
            self.path = path
        if password is not None:
            self.password = password

    # Instance attribute type: str (validator is set below)
    url = bb.Attribute("url")

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path", nullable=True)

    # Instance attribute type: str (validator is set below)
    password = bb.Attribute("password", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SharedLinkFileInfo, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SharedLinkFileInfo_validator = bv.Struct(SharedLinkFileInfo)


class SingleUserLock(bb.Struct):
    """
    :ivar SingleUserLock.created:
        The time the lock was created.
    :ivar SingleUserLock.lock_holder_account_id:
        The account ID of the lock holder if known.
    :ivar SingleUserLock.lock_holder_team_id:
        The id of the team of the account holder if it exists.
    """

    __slots__ = [
        "_created_value",
        "_lock_holder_account_id_value",
        "_lock_holder_team_id_value",
    ]

    _has_required_fields = True

    def __init__(self, created=None, lock_holder_account_id=None, lock_holder_team_id=None):
        self._created_value = bb.NOT_SET
        self._lock_holder_account_id_value = bb.NOT_SET
        self._lock_holder_team_id_value = bb.NOT_SET
        if created is not None:
            self.created = created
        if lock_holder_account_id is not None:
            self.lock_holder_account_id = lock_holder_account_id
        if lock_holder_team_id is not None:
            self.lock_holder_team_id = lock_holder_team_id

    # Instance attribute type: datetime.datetime (validator is set below)
    created = bb.Attribute("created")

    # Instance attribute type: str (validator is set below)
    lock_holder_account_id = bb.Attribute("lock_holder_account_id")

    # Instance attribute type: str (validator is set below)
    lock_holder_team_id = bb.Attribute("lock_holder_team_id", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SingleUserLock, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SingleUserLock_validator = bv.Struct(SingleUserLock)


class SymlinkInfo(bb.Struct):
    """
    :ivar SymlinkInfo.target:
        The target this symlink points to.
    """

    __slots__ = [
        "_target_value",
    ]

    _has_required_fields = True

    def __init__(self, target=None):
        self._target_value = bb.NOT_SET
        if target is not None:
            self.target = target

    # Instance attribute type: str (validator is set below)
    target = bb.Attribute("target")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SymlinkInfo, self)._process_custom_annotations(annotation_type, field_path, processor)


SymlinkInfo_validator = bv.Struct(SymlinkInfo)


class SyncSetting(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SyncSetting.default:
        On first sync to members' computers, the specified folder will follow
        its parent folder's setting or otherwise follow default sync behavior.
    :ivar SyncSetting.not_synced:
        On first sync to members' computers, the specified folder will be set to
        not sync with selective sync.
    :ivar SyncSetting.not_synced_inactive:
        The specified folder's not_synced setting is inactive due to its
        location or other configuration changes. It will follow its parent
        folder's setting.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    default = None
    # Attribute is overwritten below the class definition
    not_synced = None
    # Attribute is overwritten below the class definition
    not_synced_inactive = None
    # Attribute is overwritten below the class definition
    other = None

    def is_default(self):
        """
        Check if the union tag is ``default``.

        :rtype: bool
        """
        return self._tag == "default"

    def is_not_synced(self):
        """
        Check if the union tag is ``not_synced``.

        :rtype: bool
        """
        return self._tag == "not_synced"

    def is_not_synced_inactive(self):
        """
        Check if the union tag is ``not_synced_inactive``.

        :rtype: bool
        """
        return self._tag == "not_synced_inactive"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SyncSetting, self)._process_custom_annotations(annotation_type, field_path, processor)


SyncSetting_validator = bv.Union(SyncSetting)


class SyncSettingArg(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SyncSettingArg.default:
        On first sync to members' computers, the specified folder will follow
        its parent folder's setting or otherwise follow default sync behavior.
    :ivar SyncSettingArg.not_synced:
        On first sync to members' computers, the specified folder will be set to
        not sync with selective sync.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    default = None
    # Attribute is overwritten below the class definition
    not_synced = None
    # Attribute is overwritten below the class definition
    other = None

    def is_default(self):
        """
        Check if the union tag is ``default``.

        :rtype: bool
        """
        return self._tag == "default"

    def is_not_synced(self):
        """
        Check if the union tag is ``not_synced``.

        :rtype: bool
        """
        return self._tag == "not_synced"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SyncSettingArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SyncSettingArg_validator = bv.Union(SyncSettingArg)


class SyncSettingsError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar SyncSettingsError.unsupported_combination:
        Setting this combination of sync settings simultaneously is not
        supported.
    :ivar SyncSettingsError.unsupported_configuration:
        The specified configuration is not supported.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    unsupported_combination = None
    # Attribute is overwritten below the class definition
    unsupported_configuration = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: SyncSettingsError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_unsupported_combination(self):
        """
        Check if the union tag is ``unsupported_combination``.

        :rtype: bool
        """
        return self._tag == "unsupported_combination"

    def is_unsupported_configuration(self):
        """
        Check if the union tag is ``unsupported_configuration``.

        :rtype: bool
        """
        return self._tag == "unsupported_configuration"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(SyncSettingsError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


SyncSettingsError_validator = bv.Union(SyncSettingsError)


class Tag(bb.Union):
    """
    Tag that can be added in multiple ways.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar Tag.user_generated_tag:
        Tag generated by the user.
    :vartype Tag.user_generated_tag: UserGeneratedTag
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def user_generated_tag(cls, val):
        """
        Create an instance of this class set to the ``user_generated_tag`` tag
        with value ``val``.

        :param UserGeneratedTag val:
        :rtype: Tag
        """
        return cls("user_generated_tag", val)

    def is_user_generated_tag(self):
        """
        Check if the union tag is ``user_generated_tag``.

        :rtype: bool
        """
        return self._tag == "user_generated_tag"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_user_generated_tag(self):
        """
        Tag generated by the user.

        Only call this if :meth:`is_user_generated_tag` is true.

        :rtype: UserGeneratedTag
        """
        if not self.is_user_generated_tag():
            raise AttributeError("tag 'user_generated_tag' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(Tag, self)._process_custom_annotations(annotation_type, field_path, processor)


Tag_validator = bv.Union(Tag)


class ThumbnailArg(bb.Struct):
    """
    :ivar ThumbnailArg.path:
        The path to the image file you want to thumbnail.
    :ivar ThumbnailArg.format:
        The format for the thumbnail image, jpeg (default), png, or webp. For
        images that are photos, jpeg should be preferred, while png is better
        for screenshots and digital arts, and web for compression.
    :ivar ThumbnailArg.size:
        The size for the thumbnail image.
    :ivar ThumbnailArg.mode:
        How to resize and crop the image to achieve the desired size.
    :ivar ThumbnailArg.quality:
        Field is only returned for "internal" callers. Quality of the thumbnail
        image.
    :ivar ThumbnailArg.exclude_media_info:
        Normally, ``FileMetadata.media_info`` is set for photo and video. When
        this flag is true, ``FileMetadata.media_info`` is not populated. This
        improves latency for use cases where `media_info` is not needed.
    """

    __slots__ = [
        "_path_value",
        "_format_value",
        "_size_value",
        "_mode_value",
        "_quality_value",
        "_exclude_media_info_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        path=None,
        format=None,
        size=None,
        mode=None,
        quality=None,
        exclude_media_info=None,
    ):
        self._path_value = bb.NOT_SET
        self._format_value = bb.NOT_SET
        self._size_value = bb.NOT_SET
        self._mode_value = bb.NOT_SET
        self._quality_value = bb.NOT_SET
        self._exclude_media_info_value = bb.NOT_SET
        if path is not None:
            self.path = path
        if format is not None:
            self.format = format
        if size is not None:
            self.size = size
        if mode is not None:
            self.mode = mode
        if quality is not None:
            self.quality = quality
        if exclude_media_info is not None:
            self.exclude_media_info = exclude_media_info

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    # Instance attribute type: ThumbnailFormat (validator is set below)
    format = bb.Attribute("format", user_defined=True)

    # Instance attribute type: ThumbnailSize (validator is set below)
    size = bb.Attribute("size", user_defined=True)

    # Instance attribute type: ThumbnailMode (validator is set below)
    mode = bb.Attribute("mode", user_defined=True)

    # Instance attribute type: ThumbnailQuality (validator is set below)
    quality = bb.Attribute("quality", user_defined=True)

    # Instance attribute type: bool (validator is set below)
    exclude_media_info = bb.Attribute("exclude_media_info", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ThumbnailArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ThumbnailArg_validator = bv.Struct(ThumbnailArg)


class ThumbnailError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ThumbnailError.path:
        An error occurs when downloading metadata for the image.
    :vartype ThumbnailError.path: LookupError
    :ivar ThumbnailError.unsupported_extension:
        The file extension doesn't allow conversion to a thumbnail.
    :ivar ThumbnailError.unsupported_image:
        The image cannot be converted to a thumbnail.
    :ivar ThumbnailError.encrypted_content:
        Encrypted content cannot be converted to a thumbnail.
    :ivar ThumbnailError.conversion_error:
        An error occurs during thumbnail conversion.
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    unsupported_extension = None
    # Attribute is overwritten below the class definition
    unsupported_image = None
    # Attribute is overwritten below the class definition
    encrypted_content = None
    # Attribute is overwritten below the class definition
    conversion_error = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: ThumbnailError
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_unsupported_extension(self):
        """
        Check if the union tag is ``unsupported_extension``.

        :rtype: bool
        """
        return self._tag == "unsupported_extension"

    def is_unsupported_image(self):
        """
        Check if the union tag is ``unsupported_image``.

        :rtype: bool
        """
        return self._tag == "unsupported_image"

    def is_encrypted_content(self):
        """
        Check if the union tag is ``encrypted_content``.

        :rtype: bool
        """
        return self._tag == "encrypted_content"

    def is_conversion_error(self):
        """
        Check if the union tag is ``conversion_error``.

        :rtype: bool
        """
        return self._tag == "conversion_error"

    def get_path(self):
        """
        An error occurs when downloading metadata for the image.

        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ThumbnailError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ThumbnailError_validator = bv.Union(ThumbnailError)


class ThumbnailFormat(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    jpeg = None
    # Attribute is overwritten below the class definition
    png = None
    # Attribute is overwritten below the class definition
    webp = None

    def is_jpeg(self):
        """
        Check if the union tag is ``jpeg``.

        :rtype: bool
        """
        return self._tag == "jpeg"

    def is_png(self):
        """
        Check if the union tag is ``png``.

        :rtype: bool
        """
        return self._tag == "png"

    def is_webp(self):
        """
        Check if the union tag is ``webp``.

        :rtype: bool
        """
        return self._tag == "webp"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ThumbnailFormat, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ThumbnailFormat_validator = bv.Union(ThumbnailFormat)


class ThumbnailMode(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ThumbnailMode.strict:
        Scale down the image to fit within the given size.
    :ivar ThumbnailMode.bestfit:
        Scale down the image to fit within the given size or its transpose.
    :ivar ThumbnailMode.fitone_bestfit:
        Scale down the image to completely cover the given size or its
        transpose.
    :ivar ThumbnailMode.original:
        Don't resize the image at all.
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    strict = None
    # Attribute is overwritten below the class definition
    bestfit = None
    # Attribute is overwritten below the class definition
    fitone_bestfit = None
    # Attribute is overwritten below the class definition
    original = None

    def is_strict(self):
        """
        Check if the union tag is ``strict``.

        :rtype: bool
        """
        return self._tag == "strict"

    def is_bestfit(self):
        """
        Check if the union tag is ``bestfit``.

        :rtype: bool
        """
        return self._tag == "bestfit"

    def is_fitone_bestfit(self):
        """
        Check if the union tag is ``fitone_bestfit``.

        :rtype: bool
        """
        return self._tag == "fitone_bestfit"

    def is_original(self):
        """
        Check if the union tag is ``original``.

        :rtype: bool
        """
        return self._tag == "original"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ThumbnailMode, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ThumbnailMode_validator = bv.Union(ThumbnailMode)


class ThumbnailQuality(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ThumbnailQuality.quality_80:
        default thumbnail quality.
    :ivar ThumbnailQuality.quality_90:
        high thumbnail quality.
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    quality_80 = None
    # Attribute is overwritten below the class definition
    quality_90 = None

    def is_quality_80(self):
        """
        Check if the union tag is ``quality_80``.

        :rtype: bool
        """
        return self._tag == "quality_80"

    def is_quality_90(self):
        """
        Check if the union tag is ``quality_90``.

        :rtype: bool
        """
        return self._tag == "quality_90"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ThumbnailQuality, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ThumbnailQuality_validator = bv.Union(ThumbnailQuality)


class ThumbnailSize(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ThumbnailSize.w32h32:
        32 by 32 px.
    :ivar ThumbnailSize.w64h64:
        64 by 64 px.
    :ivar ThumbnailSize.w128h128:
        128 by 128 px.
    :ivar ThumbnailSize.w256h256:
        256 by 256 px.
    :ivar ThumbnailSize.w480h320:
        480 by 320 px.
    :ivar ThumbnailSize.w640h480:
        640 by 480 px.
    :ivar ThumbnailSize.w960h640:
        960 by 640 px.
    :ivar ThumbnailSize.w1024h768:
        1024 by 768 px.
    :ivar ThumbnailSize.w2048h1536:
        2048 by 1536 px.
    :ivar ThumbnailSize.w3200h2400:
        Field is only returned for "internal" callers. 3200 by 2400 px.
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    w32h32 = None
    # Attribute is overwritten below the class definition
    w64h64 = None
    # Attribute is overwritten below the class definition
    w128h128 = None
    # Attribute is overwritten below the class definition
    w256h256 = None
    # Attribute is overwritten below the class definition
    w480h320 = None
    # Attribute is overwritten below the class definition
    w640h480 = None
    # Attribute is overwritten below the class definition
    w960h640 = None
    # Attribute is overwritten below the class definition
    w1024h768 = None
    # Attribute is overwritten below the class definition
    w2048h1536 = None
    # Attribute is overwritten below the class definition
    w3200h2400 = None

    def is_w32h32(self):
        """
        Check if the union tag is ``w32h32``.

        :rtype: bool
        """
        return self._tag == "w32h32"

    def is_w64h64(self):
        """
        Check if the union tag is ``w64h64``.

        :rtype: bool
        """
        return self._tag == "w64h64"

    def is_w128h128(self):
        """
        Check if the union tag is ``w128h128``.

        :rtype: bool
        """
        return self._tag == "w128h128"

    def is_w256h256(self):
        """
        Check if the union tag is ``w256h256``.

        :rtype: bool
        """
        return self._tag == "w256h256"

    def is_w480h320(self):
        """
        Check if the union tag is ``w480h320``.

        :rtype: bool
        """
        return self._tag == "w480h320"

    def is_w640h480(self):
        """
        Check if the union tag is ``w640h480``.

        :rtype: bool
        """
        return self._tag == "w640h480"

    def is_w960h640(self):
        """
        Check if the union tag is ``w960h640``.

        :rtype: bool
        """
        return self._tag == "w960h640"

    def is_w1024h768(self):
        """
        Check if the union tag is ``w1024h768``.

        :rtype: bool
        """
        return self._tag == "w1024h768"

    def is_w2048h1536(self):
        """
        Check if the union tag is ``w2048h1536``.

        :rtype: bool
        """
        return self._tag == "w2048h1536"

    def is_w3200h2400(self):
        """
        Check if the union tag is ``w3200h2400``.

        :rtype: bool
        """
        return self._tag == "w3200h2400"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ThumbnailSize, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ThumbnailSize_validator = bv.Union(ThumbnailSize)


class ThumbnailV2Arg(bb.Struct):
    """
    :ivar ThumbnailV2Arg.resource:
        Information specifying which file to preview. This could be a path to a
        file, a shared link pointing to a file, or a shared link pointing to a
        folder, with a relative path.
    :ivar ThumbnailV2Arg.format:
        The format for the thumbnail image, jpeg (default), png, or webp. For
        images that are photos, jpeg should be preferred, while png is better
        for screenshots and digital arts, and web for compression.
    :ivar ThumbnailV2Arg.size:
        The size for the thumbnail image.
    :ivar ThumbnailV2Arg.mode:
        How to resize and crop the image to achieve the desired size.
    :ivar ThumbnailV2Arg.quality:
        Field is only returned for "internal" callers. Quality of the thumbnail
        image.
    :ivar ThumbnailV2Arg.exclude_media_info:
        Normally, ``FileMetadata.media_info`` is set for photo and video. When
        this flag is true, ``FileMetadata.media_info`` is not populated. This
        improves latency for use cases where `media_info` is not needed.
    """

    __slots__ = [
        "_resource_value",
        "_format_value",
        "_size_value",
        "_mode_value",
        "_quality_value",
        "_exclude_media_info_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        resource=None,
        format=None,
        size=None,
        mode=None,
        quality=None,
        exclude_media_info=None,
    ):
        self._resource_value = bb.NOT_SET
        self._format_value = bb.NOT_SET
        self._size_value = bb.NOT_SET
        self._mode_value = bb.NOT_SET
        self._quality_value = bb.NOT_SET
        self._exclude_media_info_value = bb.NOT_SET
        if resource is not None:
            self.resource = resource
        if format is not None:
            self.format = format
        if size is not None:
            self.size = size
        if mode is not None:
            self.mode = mode
        if quality is not None:
            self.quality = quality
        if exclude_media_info is not None:
            self.exclude_media_info = exclude_media_info

    # Instance attribute type: PathOrLink (validator is set below)
    resource = bb.Attribute("resource", user_defined=True)

    # Instance attribute type: ThumbnailFormat (validator is set below)
    format = bb.Attribute("format", user_defined=True)

    # Instance attribute type: ThumbnailSize (validator is set below)
    size = bb.Attribute("size", user_defined=True)

    # Instance attribute type: ThumbnailMode (validator is set below)
    mode = bb.Attribute("mode", user_defined=True)

    # Instance attribute type: ThumbnailQuality (validator is set below)
    quality = bb.Attribute("quality", user_defined=True)

    # Instance attribute type: bool (validator is set below)
    exclude_media_info = bb.Attribute("exclude_media_info", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ThumbnailV2Arg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ThumbnailV2Arg_validator = bv.Struct(ThumbnailV2Arg)


class ThumbnailV2Error(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar ThumbnailV2Error.path:
        An error occurred when downloading metadata for the image.
    :vartype ThumbnailV2Error.path: LookupError
    :ivar ThumbnailV2Error.unsupported_extension:
        The file extension doesn't allow conversion to a thumbnail.
    :ivar ThumbnailV2Error.unsupported_image:
        The image cannot be converted to a thumbnail.
    :ivar ThumbnailV2Error.encrypted_content:
        Encrypted content cannot be converted to a thumbnail.
    :ivar ThumbnailV2Error.conversion_error:
        An error occurred during thumbnail conversion.
    :ivar ThumbnailV2Error.access_denied:
        Access to this shared link is forbidden.
    :ivar ThumbnailV2Error.not_found:
        The shared link does not exist.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    unsupported_extension = None
    # Attribute is overwritten below the class definition
    unsupported_image = None
    # Attribute is overwritten below the class definition
    encrypted_content = None
    # Attribute is overwritten below the class definition
    conversion_error = None
    # Attribute is overwritten below the class definition
    access_denied = None
    # Attribute is overwritten below the class definition
    not_found = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param LookupError val:
        :rtype: ThumbnailV2Error
        """
        return cls("path", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_unsupported_extension(self):
        """
        Check if the union tag is ``unsupported_extension``.

        :rtype: bool
        """
        return self._tag == "unsupported_extension"

    def is_unsupported_image(self):
        """
        Check if the union tag is ``unsupported_image``.

        :rtype: bool
        """
        return self._tag == "unsupported_image"

    def is_encrypted_content(self):
        """
        Check if the union tag is ``encrypted_content``.

        :rtype: bool
        """
        return self._tag == "encrypted_content"

    def is_conversion_error(self):
        """
        Check if the union tag is ``conversion_error``.

        :rtype: bool
        """
        return self._tag == "conversion_error"

    def is_access_denied(self):
        """
        Check if the union tag is ``access_denied``.

        :rtype: bool
        """
        return self._tag == "access_denied"

    def is_not_found(self):
        """
        Check if the union tag is ``not_found``.

        :rtype: bool
        """
        return self._tag == "not_found"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        An error occurred when downloading metadata for the image.

        Only call this if :meth:`is_path` is true.

        :rtype: LookupError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(ThumbnailV2Error, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


ThumbnailV2Error_validator = bv.Union(ThumbnailV2Error)


class UnlockFileArg(bb.Struct):
    """
    :ivar UnlockFileArg.path:
        Path in the user's Dropbox to a file.
    """

    __slots__ = [
        "_path_value",
    ]

    _has_required_fields = True

    def __init__(self, path=None):
        self._path_value = bb.NOT_SET
        if path is not None:
            self.path = path

    # Instance attribute type: str (validator is set below)
    path = bb.Attribute("path")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UnlockFileArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UnlockFileArg_validator = bv.Struct(UnlockFileArg)


class UnlockFileBatchArg(bb.Struct):
    """
    :ivar UnlockFileBatchArg.entries:
        List of 'entries'. Each 'entry' contains a path of the file which will
        be unlocked. Duplicate path arguments in the batch are considered only
        once.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [UnlockFileArg] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UnlockFileBatchArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UnlockFileBatchArg_validator = bv.Struct(UnlockFileBatchArg)


class UploadArg(CommitInfo):
    """
    :ivar UploadArg.content_hash:
        A hash of the file content uploaded in this call. If provided and the
        uploaded content does not match this hash, an error will be returned.
        For more information see our `Content hash
        <https://www.dropbox.com/developers/reference/content-hash>`_ page.
    """

    __slots__ = [
        "_content_hash_value",
    ]

    _has_required_fields = True

    def __init__(
        self,
        path=None,
        mode=None,
        autorename=None,
        client_modified=None,
        mute=None,
        property_groups=None,
        strict_conflict=None,
        content_hash=None,
    ):
        super(UploadArg, self).__init__(
            path,
            mode,
            autorename,
            client_modified,
            mute,
            property_groups,
            strict_conflict,
        )
        self._content_hash_value = bb.NOT_SET
        if content_hash is not None:
            self.content_hash = content_hash

    # Instance attribute type: str (validator is set below)
    content_hash = bb.Attribute("content_hash", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadArg, self)._process_custom_annotations(annotation_type, field_path, processor)


UploadArg_validator = bv.Struct(UploadArg)


class UploadError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar UploadError.path:
        Unable to save the uploaded contents to a file.
    :vartype UploadError.path: UploadWriteFailed
    :ivar UploadError.properties_error:
        The supplied property group is invalid. The file has uploaded without
        property groups.
    :vartype UploadError.properties_error: file_properties.InvalidPropertyGroupError
    :ivar UploadError.payload_too_large:
        The request payload must be at most 150 MiB.
    :ivar UploadError.content_hash_mismatch:
        The content received by the Dropbox server in this call does not match
        the provided content hash.
    :ivar UploadError.encryption_not_supported:
        The file is required to be encrypted, which is not supported in our
        public API.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    payload_too_large = None
    # Attribute is overwritten below the class definition
    content_hash_mismatch = None
    # Attribute is overwritten below the class definition
    encryption_not_supported = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param UploadWriteFailed val:
        :rtype: UploadError
        """
        return cls("path", val)

    @classmethod
    def properties_error(cls, val):
        """
        Create an instance of this class set to the ``properties_error`` tag
        with value ``val``.

        :param file_properties.InvalidPropertyGroupError val:
        :rtype: UploadError
        """
        return cls("properties_error", val)

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_properties_error(self):
        """
        Check if the union tag is ``properties_error``.

        :rtype: bool
        """
        return self._tag == "properties_error"

    def is_payload_too_large(self):
        """
        Check if the union tag is ``payload_too_large``.

        :rtype: bool
        """
        return self._tag == "payload_too_large"

    def is_content_hash_mismatch(self):
        """
        Check if the union tag is ``content_hash_mismatch``.

        :rtype: bool
        """
        return self._tag == "content_hash_mismatch"

    def is_encryption_not_supported(self):
        """
        Check if the union tag is ``encryption_not_supported``.

        :rtype: bool
        """
        return self._tag == "encryption_not_supported"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_path(self):
        """
        Unable to save the uploaded contents to a file.

        Only call this if :meth:`is_path` is true.

        :rtype: UploadWriteFailed
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def get_properties_error(self):
        """
        The supplied property group is invalid. The file has uploaded without
        property groups.

        Only call this if :meth:`is_properties_error` is true.

        :rtype: file_properties.InvalidPropertyGroupError
        """
        if not self.is_properties_error():
            raise AttributeError("tag 'properties_error' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadError, self)._process_custom_annotations(annotation_type, field_path, processor)


UploadError_validator = bv.Union(UploadError)


class UploadSessionAppendArg(bb.Struct):
    """
    :ivar UploadSessionAppendArg.cursor:
        Contains the upload session ID and the offset.
    :ivar UploadSessionAppendArg.close:
        If true, the current session will be closed, at which point you won't be
        able to call
        :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_append`
        anymore with the current session.
    :ivar UploadSessionAppendArg.content_hash:
        A hash of the file content uploaded in this call. If provided and the
        uploaded content does not match this hash, an error will be returned.
        For more information see our `Content hash
        <https://www.dropbox.com/developers/reference/content-hash>`_ page.
    """

    __slots__ = [
        "_cursor_value",
        "_close_value",
        "_content_hash_value",
    ]

    _has_required_fields = True

    def __init__(self, cursor=None, close=None, content_hash=None):
        self._cursor_value = bb.NOT_SET
        self._close_value = bb.NOT_SET
        self._content_hash_value = bb.NOT_SET
        if cursor is not None:
            self.cursor = cursor
        if close is not None:
            self.close = close
        if content_hash is not None:
            self.content_hash = content_hash

    # Instance attribute type: UploadSessionCursor (validator is set below)
    cursor = bb.Attribute("cursor", user_defined=True)

    # Instance attribute type: bool (validator is set below)
    close = bb.Attribute("close")

    # Instance attribute type: str (validator is set below)
    content_hash = bb.Attribute("content_hash", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionAppendArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionAppendArg_validator = bv.Struct(UploadSessionAppendArg)


class UploadSessionAppendBatchArg(bb.Struct):
    """
    :ivar UploadSessionAppendBatchArg.entries:
        Append information for each file in the batch.
    :ivar UploadSessionAppendBatchArg.content_hash:
        A hash of the entire request body which is all the concatenated pieces
        of file content that were uploaded in this call. If provided and the
        uploaded content does not match this hash, an error will be returned.
        For more information see our `Content hash
        <https://www.dropbox.com/developers/reference/content-hash>`_ page.
    """

    __slots__ = [
        "_entries_value",
        "_content_hash_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None, content_hash=None):
        self._entries_value = bb.NOT_SET
        self._content_hash_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries
        if content_hash is not None:
            self.content_hash = content_hash

    # Instance attribute type: list of [UploadSessionAppendBatchArgEntry] (validator is set below)
    entries = bb.Attribute("entries")

    # Instance attribute type: str (validator is set below)
    content_hash = bb.Attribute("content_hash", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionAppendBatchArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionAppendBatchArg_validator = bv.Struct(UploadSessionAppendBatchArg)


class UploadSessionAppendBatchArgEntry(bb.Struct):
    """
    :ivar UploadSessionAppendBatchArgEntry.cursor:
        Contains the upload session ID and the offset.
    :ivar UploadSessionAppendBatchArgEntry.length:
        Length in bytes of the data that should be appended for this session.
        Used to split the batched upload data for multiple upload sessions.
    :ivar UploadSessionAppendBatchArgEntry.close:
        If true, the current session will be closed, at which point you won't be
        able to call
        :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_append_batch`
        anymore with the current session.
    """

    __slots__ = [
        "_cursor_value",
        "_length_value",
        "_close_value",
    ]

    _has_required_fields = True

    def __init__(self, cursor=None, length=None, close=None):
        self._cursor_value = bb.NOT_SET
        self._length_value = bb.NOT_SET
        self._close_value = bb.NOT_SET
        if cursor is not None:
            self.cursor = cursor
        if length is not None:
            self.length = length
        if close is not None:
            self.close = close

    # Instance attribute type: UploadSessionCursor (validator is set below)
    cursor = bb.Attribute("cursor", user_defined=True)

    # Instance attribute type: int (validator is set below)
    length = bb.Attribute("length")

    # Instance attribute type: bool (validator is set below)
    close = bb.Attribute("close")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionAppendBatchArgEntry, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionAppendBatchArgEntry_validator = bv.Struct(UploadSessionAppendBatchArgEntry)


class UploadSessionAppendBatchEntryError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar UploadSessionAppendBatchEntryError.not_found:
        The upload session ID was not found or has expired. Upload sessions are
        valid for 7 days.
    :ivar UploadSessionAppendBatchEntryError.incorrect_offset:
        The specified offset was incorrect. See the value for the correct
        offset. This error may occur when a previous request was received and
        processed successfully but the client did not receive the response, e.g.
        due to a network error.
    :vartype UploadSessionAppendBatchEntryError.incorrect_offset: UploadSessionOffsetError
    :ivar UploadSessionAppendBatchEntryError.closed:
        You are attempting to append data to an upload session that has already
        been closed (i.e. committed).
    :ivar UploadSessionAppendBatchEntryError.too_large:
        You can not append to the upload session because the size of a file
        should not exceed the max file size limit (i.e. 2^41 - 2^22 or
        2,199,019,061,248 bytes).
    :ivar UploadSessionAppendBatchEntryError.concurrent_session_invalid_offset:
        For concurrent upload sessions, offset needs to be multiple of 2^22
        (4,194,304) bytes.
    :ivar UploadSessionAppendBatchEntryError.concurrent_session_invalid_data_size:
        For concurrent upload sessions, only chunks with size multiple of 2^22
        (4,194,304) bytes can be uploaded.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    not_found = None
    # Attribute is overwritten below the class definition
    closed = None
    # Attribute is overwritten below the class definition
    too_large = None
    # Attribute is overwritten below the class definition
    concurrent_session_invalid_offset = None
    # Attribute is overwritten below the class definition
    concurrent_session_invalid_data_size = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def incorrect_offset(cls, val):
        """
        Create an instance of this class set to the ``incorrect_offset`` tag
        with value ``val``.

        :param UploadSessionOffsetError val:
        :rtype: UploadSessionAppendBatchEntryError
        """
        return cls("incorrect_offset", val)

    def is_not_found(self):
        """
        Check if the union tag is ``not_found``.

        :rtype: bool
        """
        return self._tag == "not_found"

    def is_incorrect_offset(self):
        """
        Check if the union tag is ``incorrect_offset``.

        :rtype: bool
        """
        return self._tag == "incorrect_offset"

    def is_closed(self):
        """
        Check if the union tag is ``closed``.

        :rtype: bool
        """
        return self._tag == "closed"

    def is_too_large(self):
        """
        Check if the union tag is ``too_large``.

        :rtype: bool
        """
        return self._tag == "too_large"

    def is_concurrent_session_invalid_offset(self):
        """
        Check if the union tag is ``concurrent_session_invalid_offset``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_invalid_offset"

    def is_concurrent_session_invalid_data_size(self):
        """
        Check if the union tag is ``concurrent_session_invalid_data_size``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_invalid_data_size"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_incorrect_offset(self):
        """
        The specified offset was incorrect. See the value for the correct
        offset. This error may occur when a previous request was received and
        processed successfully but the client did not receive the response, e.g.
        due to a network error.

        Only call this if :meth:`is_incorrect_offset` is true.

        :rtype: UploadSessionOffsetError
        """
        if not self.is_incorrect_offset():
            raise AttributeError("tag 'incorrect_offset' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionAppendBatchEntryError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionAppendBatchEntryError_validator = bv.Union(UploadSessionAppendBatchEntryError)


class UploadSessionAppendBatchError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar UploadSessionAppendBatchError.payload_too_large:
        The request payload must be at most 150 MiB.
    :ivar UploadSessionAppendBatchError.content_hash_mismatch:
        The content received by the Dropbox server in this call does not match
        the provided content hash.
    :ivar UploadSessionAppendBatchError.length_mismatch:
        The total length of the content received by the Dropbox server in this
        call does not match the total of the provided lengths in the batch
        arguments.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    payload_too_large = None
    # Attribute is overwritten below the class definition
    content_hash_mismatch = None
    # Attribute is overwritten below the class definition
    length_mismatch = None
    # Attribute is overwritten below the class definition
    other = None

    def is_payload_too_large(self):
        """
        Check if the union tag is ``payload_too_large``.

        :rtype: bool
        """
        return self._tag == "payload_too_large"

    def is_content_hash_mismatch(self):
        """
        Check if the union tag is ``content_hash_mismatch``.

        :rtype: bool
        """
        return self._tag == "content_hash_mismatch"

    def is_length_mismatch(self):
        """
        Check if the union tag is ``length_mismatch``.

        :rtype: bool
        """
        return self._tag == "length_mismatch"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionAppendBatchError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionAppendBatchError_validator = bv.Union(UploadSessionAppendBatchError)


class UploadSessionAppendBatchResult(bb.Struct):
    """
    :ivar UploadSessionAppendBatchResult.entries:
        Each entry in ``UploadSessionAppendBatchArg.entries`` will appear at the
        same position inside ``UploadSessionAppendBatchResult.entries``.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [UploadSessionAppendBatchResultEntry] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionAppendBatchResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionAppendBatchResult_validator = bv.Struct(UploadSessionAppendBatchResult)


class UploadSessionAppendBatchResultEntry(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    success = None

    @classmethod
    def failure(cls, val):
        """
        Create an instance of this class set to the ``failure`` tag with value
        ``val``.

        :param UploadSessionAppendBatchEntryError val:
        :rtype: UploadSessionAppendBatchResultEntry
        """
        return cls("failure", val)

    def is_success(self):
        """
        Check if the union tag is ``success``.

        :rtype: bool
        """
        return self._tag == "success"

    def is_failure(self):
        """
        Check if the union tag is ``failure``.

        :rtype: bool
        """
        return self._tag == "failure"

    def get_failure(self):
        """
        Only call this if :meth:`is_failure` is true.

        :rtype: UploadSessionAppendBatchEntryError
        """
        if not self.is_failure():
            raise AttributeError("tag 'failure' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionAppendBatchResultEntry, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionAppendBatchResultEntry_validator = bv.Union(UploadSessionAppendBatchResultEntry)


class UploadSessionAppendError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar UploadSessionAppendError.not_found:
        The upload session ID was not found or has expired. Upload sessions are
        valid for 7 days.
    :ivar UploadSessionAppendError.incorrect_offset:
        The specified offset was incorrect. See the value for the correct
        offset. This error may occur when a previous request was received and
        processed successfully but the client did not receive the response, e.g.
        due to a network error.
    :vartype UploadSessionAppendError.incorrect_offset: UploadSessionOffsetError
    :ivar UploadSessionAppendError.closed:
        You are attempting to append data to an upload session that has already
        been closed (i.e. committed).
    :ivar UploadSessionAppendError.too_large:
        You can not append to the upload session because the size of a file
        should not exceed the max file size limit (i.e. 2^41 - 2^22 or
        2,199,019,061,248 bytes).
    :ivar UploadSessionAppendError.concurrent_session_invalid_offset:
        For concurrent upload sessions, offset needs to be multiple of 2^22
        (4,194,304) bytes.
    :ivar UploadSessionAppendError.concurrent_session_invalid_data_size:
        For concurrent upload sessions, only chunks with size multiple of 2^22
        (4,194,304) bytes can be uploaded.
    :ivar UploadSessionAppendError.payload_too_large:
        The request payload must be at most 150 MiB.
    :ivar UploadSessionAppendError.content_hash_mismatch:
        The content received by the Dropbox server in this call does not match
        the provided content hash.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    not_found = None
    # Attribute is overwritten below the class definition
    closed = None
    # Attribute is overwritten below the class definition
    too_large = None
    # Attribute is overwritten below the class definition
    concurrent_session_invalid_offset = None
    # Attribute is overwritten below the class definition
    concurrent_session_invalid_data_size = None
    # Attribute is overwritten below the class definition
    payload_too_large = None
    # Attribute is overwritten below the class definition
    content_hash_mismatch = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def incorrect_offset(cls, val):
        """
        Create an instance of this class set to the ``incorrect_offset`` tag
        with value ``val``.

        :param UploadSessionOffsetError val:
        :rtype: UploadSessionAppendError
        """
        return cls("incorrect_offset", val)

    def is_not_found(self):
        """
        Check if the union tag is ``not_found``.

        :rtype: bool
        """
        return self._tag == "not_found"

    def is_incorrect_offset(self):
        """
        Check if the union tag is ``incorrect_offset``.

        :rtype: bool
        """
        return self._tag == "incorrect_offset"

    def is_closed(self):
        """
        Check if the union tag is ``closed``.

        :rtype: bool
        """
        return self._tag == "closed"

    def is_too_large(self):
        """
        Check if the union tag is ``too_large``.

        :rtype: bool
        """
        return self._tag == "too_large"

    def is_concurrent_session_invalid_offset(self):
        """
        Check if the union tag is ``concurrent_session_invalid_offset``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_invalid_offset"

    def is_concurrent_session_invalid_data_size(self):
        """
        Check if the union tag is ``concurrent_session_invalid_data_size``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_invalid_data_size"

    def is_payload_too_large(self):
        """
        Check if the union tag is ``payload_too_large``.

        :rtype: bool
        """
        return self._tag == "payload_too_large"

    def is_content_hash_mismatch(self):
        """
        Check if the union tag is ``content_hash_mismatch``.

        :rtype: bool
        """
        return self._tag == "content_hash_mismatch"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_incorrect_offset(self):
        """
        The specified offset was incorrect. See the value for the correct
        offset. This error may occur when a previous request was received and
        processed successfully but the client did not receive the response, e.g.
        due to a network error.

        Only call this if :meth:`is_incorrect_offset` is true.

        :rtype: UploadSessionOffsetError
        """
        if not self.is_incorrect_offset():
            raise AttributeError("tag 'incorrect_offset' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionAppendError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionAppendError_validator = bv.Union(UploadSessionAppendError)


class UploadSessionCursor(bb.Struct):
    """
    :ivar UploadSessionCursor.session_id:
        The upload session ID (returned by
        :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_start`).
    :ivar UploadSessionCursor.offset:
        Offset in bytes at which data should be appended. We use this to make
        sure upload data isn't lost or duplicated in the event of a network
        error.
    """

    __slots__ = [
        "_session_id_value",
        "_offset_value",
    ]

    _has_required_fields = True

    def __init__(self, session_id=None, offset=None):
        self._session_id_value = bb.NOT_SET
        self._offset_value = bb.NOT_SET
        if session_id is not None:
            self.session_id = session_id
        if offset is not None:
            self.offset = offset

    # Instance attribute type: str (validator is set below)
    session_id = bb.Attribute("session_id")

    # Instance attribute type: int (validator is set below)
    offset = bb.Attribute("offset")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionCursor, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionCursor_validator = bv.Struct(UploadSessionCursor)


class UploadSessionFinishArg(bb.Struct):
    """
    :ivar UploadSessionFinishArg.cursor:
        Contains the upload session ID and the offset.
    :ivar UploadSessionFinishArg.commit:
        Contains the path and other optional modifiers for the commit.
    :ivar UploadSessionFinishArg.content_hash:
        A hash of the file content uploaded in this call. If provided and the
        uploaded content does not match this hash, an error will be returned.
        For more information see our `Content hash
        <https://www.dropbox.com/developers/reference/content-hash>`_ page.
    """

    __slots__ = [
        "_cursor_value",
        "_commit_value",
        "_content_hash_value",
    ]

    _has_required_fields = True

    def __init__(self, cursor=None, commit=None, content_hash=None):
        self._cursor_value = bb.NOT_SET
        self._commit_value = bb.NOT_SET
        self._content_hash_value = bb.NOT_SET
        if cursor is not None:
            self.cursor = cursor
        if commit is not None:
            self.commit = commit
        if content_hash is not None:
            self.content_hash = content_hash

    # Instance attribute type: UploadSessionCursor (validator is set below)
    cursor = bb.Attribute("cursor", user_defined=True)

    # Instance attribute type: CommitInfo (validator is set below)
    commit = bb.Attribute("commit", user_defined=True)

    # Instance attribute type: str (validator is set below)
    content_hash = bb.Attribute("content_hash", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionFinishArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionFinishArg_validator = bv.Struct(UploadSessionFinishArg)


class UploadSessionFinishBatchArg(bb.Struct):
    """
    :ivar UploadSessionFinishBatchArg.entries:
        Commit information for each file in the batch.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [UploadSessionFinishArg] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionFinishBatchArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionFinishBatchArg_validator = bv.Struct(UploadSessionFinishBatchArg)


class UploadSessionFinishBatchJobStatus(async_.PollResultBase):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar UploadSessionFinishBatchJobStatus.complete:
        The
        :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_finish_batch`
        has finished.
    :vartype UploadSessionFinishBatchJobStatus.complete: UploadSessionFinishBatchResult
    """

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param UploadSessionFinishBatchResult val:
        :rtype: UploadSessionFinishBatchJobStatus
        """
        return cls("complete", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def get_complete(self):
        """
        The
        :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_finish_batch`
        has finished.

        Only call this if :meth:`is_complete` is true.

        :rtype: UploadSessionFinishBatchResult
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionFinishBatchJobStatus, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionFinishBatchJobStatus_validator = bv.Union(UploadSessionFinishBatchJobStatus)


class UploadSessionFinishBatchLaunch(async_.LaunchResultBase):
    """
    Result returned by
    :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_finish_batch`
    that may either launch an asynchronous job or complete synchronously.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def complete(cls, val):
        """
        Create an instance of this class set to the ``complete`` tag with value
        ``val``.

        :param UploadSessionFinishBatchResult val:
        :rtype: UploadSessionFinishBatchLaunch
        """
        return cls("complete", val)

    def is_complete(self):
        """
        Check if the union tag is ``complete``.

        :rtype: bool
        """
        return self._tag == "complete"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_complete(self):
        """
        Only call this if :meth:`is_complete` is true.

        :rtype: UploadSessionFinishBatchResult
        """
        if not self.is_complete():
            raise AttributeError("tag 'complete' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionFinishBatchLaunch, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionFinishBatchLaunch_validator = bv.Union(UploadSessionFinishBatchLaunch)


class UploadSessionFinishBatchResult(bb.Struct):
    """
    :ivar UploadSessionFinishBatchResult.entries:
        Each entry in ``UploadSessionFinishBatchArg.entries`` will appear at the
        same position inside ``UploadSessionFinishBatchResult.entries``.
    """

    __slots__ = [
        "_entries_value",
    ]

    _has_required_fields = True

    def __init__(self, entries=None):
        self._entries_value = bb.NOT_SET
        if entries is not None:
            self.entries = entries

    # Instance attribute type: list of [UploadSessionFinishBatchResultEntry] (validator is set below)
    entries = bb.Attribute("entries")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionFinishBatchResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionFinishBatchResult_validator = bv.Struct(UploadSessionFinishBatchResult)


class UploadSessionFinishBatchResultEntry(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.
    """

    _catch_all = None

    @classmethod
    def success(cls, val):
        """
        Create an instance of this class set to the ``success`` tag with value
        ``val``.

        :param FileMetadata val:
        :rtype: UploadSessionFinishBatchResultEntry
        """
        return cls("success", val)

    @classmethod
    def failure(cls, val):
        """
        Create an instance of this class set to the ``failure`` tag with value
        ``val``.

        :param UploadSessionFinishError val:
        :rtype: UploadSessionFinishBatchResultEntry
        """
        return cls("failure", val)

    def is_success(self):
        """
        Check if the union tag is ``success``.

        :rtype: bool
        """
        return self._tag == "success"

    def is_failure(self):
        """
        Check if the union tag is ``failure``.

        :rtype: bool
        """
        return self._tag == "failure"

    def get_success(self):
        """
        Only call this if :meth:`is_success` is true.

        :rtype: FileMetadata
        """
        if not self.is_success():
            raise AttributeError("tag 'success' not set")
        return self._value

    def get_failure(self):
        """
        Only call this if :meth:`is_failure` is true.

        :rtype: UploadSessionFinishError
        """
        if not self.is_failure():
            raise AttributeError("tag 'failure' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionFinishBatchResultEntry, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionFinishBatchResultEntry_validator = bv.Union(UploadSessionFinishBatchResultEntry)


class UploadSessionFinishError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar UploadSessionFinishError.lookup_failed:
        The session arguments are incorrect; the value explains the reason.
    :vartype UploadSessionFinishError.lookup_failed: UploadSessionLookupError
    :ivar UploadSessionFinishError.path:
        Unable to save the uploaded contents to a file. Data has already been
        appended to the upload session. Please retry with empty data body and
        updated offset.
    :vartype UploadSessionFinishError.path: WriteError
    :ivar UploadSessionFinishError.properties_error:
        The supplied property group is invalid. The file has uploaded without
        property groups.
    :vartype UploadSessionFinishError.properties_error: file_properties.InvalidPropertyGroupError
    :ivar UploadSessionFinishError.too_many_shared_folder_targets:
        Field is deprecated. The batch request commits files into too many
        different shared folders. Please limit your batch request to files
        contained in a single shared folder.
    :ivar UploadSessionFinishError.too_many_write_operations:
        There are too many write operations happening in the user's Dropbox. You
        should retry uploading this file.
    :ivar UploadSessionFinishError.concurrent_session_data_not_allowed:
        Uploading data not allowed when finishing concurrent upload session.
    :ivar UploadSessionFinishError.concurrent_session_not_closed:
        Concurrent upload sessions need to be closed before finishing.
    :ivar UploadSessionFinishError.concurrent_session_missing_data:
        Not all pieces of data were uploaded before trying to finish the
        session.
    :ivar UploadSessionFinishError.payload_too_large:
        The request payload must be at most 150 MiB.
    :ivar UploadSessionFinishError.content_hash_mismatch:
        The content received by the Dropbox server in this call does not match
        the provided content hash.
    :ivar UploadSessionFinishError.encryption_not_supported:
        The file is required to be encrypted, which is not supported in our
        public API.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    too_many_shared_folder_targets = None
    # Attribute is overwritten below the class definition
    too_many_write_operations = None
    # Attribute is overwritten below the class definition
    concurrent_session_data_not_allowed = None
    # Attribute is overwritten below the class definition
    concurrent_session_not_closed = None
    # Attribute is overwritten below the class definition
    concurrent_session_missing_data = None
    # Attribute is overwritten below the class definition
    payload_too_large = None
    # Attribute is overwritten below the class definition
    content_hash_mismatch = None
    # Attribute is overwritten below the class definition
    encryption_not_supported = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def lookup_failed(cls, val):
        """
        Create an instance of this class set to the ``lookup_failed`` tag with
        value ``val``.

        :param UploadSessionLookupError val:
        :rtype: UploadSessionFinishError
        """
        return cls("lookup_failed", val)

    @classmethod
    def path(cls, val):
        """
        Create an instance of this class set to the ``path`` tag with value
        ``val``.

        :param WriteError val:
        :rtype: UploadSessionFinishError
        """
        return cls("path", val)

    @classmethod
    def properties_error(cls, val):
        """
        Create an instance of this class set to the ``properties_error`` tag
        with value ``val``.

        :param file_properties.InvalidPropertyGroupError val:
        :rtype: UploadSessionFinishError
        """
        return cls("properties_error", val)

    def is_lookup_failed(self):
        """
        Check if the union tag is ``lookup_failed``.

        :rtype: bool
        """
        return self._tag == "lookup_failed"

    def is_path(self):
        """
        Check if the union tag is ``path``.

        :rtype: bool
        """
        return self._tag == "path"

    def is_properties_error(self):
        """
        Check if the union tag is ``properties_error``.

        :rtype: bool
        """
        return self._tag == "properties_error"

    def is_too_many_shared_folder_targets(self):
        """
        Check if the union tag is ``too_many_shared_folder_targets``.

        :rtype: bool
        """
        return self._tag == "too_many_shared_folder_targets"

    def is_too_many_write_operations(self):
        """
        Check if the union tag is ``too_many_write_operations``.

        :rtype: bool
        """
        return self._tag == "too_many_write_operations"

    def is_concurrent_session_data_not_allowed(self):
        """
        Check if the union tag is ``concurrent_session_data_not_allowed``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_data_not_allowed"

    def is_concurrent_session_not_closed(self):
        """
        Check if the union tag is ``concurrent_session_not_closed``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_not_closed"

    def is_concurrent_session_missing_data(self):
        """
        Check if the union tag is ``concurrent_session_missing_data``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_missing_data"

    def is_payload_too_large(self):
        """
        Check if the union tag is ``payload_too_large``.

        :rtype: bool
        """
        return self._tag == "payload_too_large"

    def is_content_hash_mismatch(self):
        """
        Check if the union tag is ``content_hash_mismatch``.

        :rtype: bool
        """
        return self._tag == "content_hash_mismatch"

    def is_encryption_not_supported(self):
        """
        Check if the union tag is ``encryption_not_supported``.

        :rtype: bool
        """
        return self._tag == "encryption_not_supported"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_lookup_failed(self):
        """
        The session arguments are incorrect; the value explains the reason.

        Only call this if :meth:`is_lookup_failed` is true.

        :rtype: UploadSessionLookupError
        """
        if not self.is_lookup_failed():
            raise AttributeError("tag 'lookup_failed' not set")
        return self._value

    def get_path(self):
        """
        Unable to save the uploaded contents to a file. Data has already been
        appended to the upload session. Please retry with empty data body and
        updated offset.

        Only call this if :meth:`is_path` is true.

        :rtype: WriteError
        """
        if not self.is_path():
            raise AttributeError("tag 'path' not set")
        return self._value

    def get_properties_error(self):
        """
        The supplied property group is invalid. The file has uploaded without
        property groups.

        Only call this if :meth:`is_properties_error` is true.

        :rtype: file_properties.InvalidPropertyGroupError
        """
        if not self.is_properties_error():
            raise AttributeError("tag 'properties_error' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionFinishError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionFinishError_validator = bv.Union(UploadSessionFinishError)


class UploadSessionLookupError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar UploadSessionLookupError.not_found:
        The upload session ID was not found or has expired. Upload sessions are
        valid for 7 days.
    :ivar UploadSessionLookupError.incorrect_offset:
        The specified offset was incorrect. See the value for the correct
        offset. This error may occur when a previous request was received and
        processed successfully but the client did not receive the response, e.g.
        due to a network error.
    :vartype UploadSessionLookupError.incorrect_offset: UploadSessionOffsetError
    :ivar UploadSessionLookupError.closed:
        You are attempting to append data to an upload session that has already
        been closed (i.e. committed).
    :ivar UploadSessionLookupError.not_closed:
        The session must be closed before calling upload_session/finish_batch.
    :ivar UploadSessionLookupError.too_large:
        You can not append to the upload session because the size of a file
        should not exceed the max file size limit (i.e. 2^41 - 2^22 or
        2,199,019,061,248 bytes).
    :ivar UploadSessionLookupError.concurrent_session_invalid_offset:
        For concurrent upload sessions, offset needs to be multiple of 2^22
        (4,194,304) bytes.
    :ivar UploadSessionLookupError.concurrent_session_invalid_data_size:
        For concurrent upload sessions, only chunks with size multiple of 2^22
        (4,194,304) bytes can be uploaded.
    :ivar UploadSessionLookupError.payload_too_large:
        The request payload must be at most 150 MiB.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    not_found = None
    # Attribute is overwritten below the class definition
    closed = None
    # Attribute is overwritten below the class definition
    not_closed = None
    # Attribute is overwritten below the class definition
    too_large = None
    # Attribute is overwritten below the class definition
    concurrent_session_invalid_offset = None
    # Attribute is overwritten below the class definition
    concurrent_session_invalid_data_size = None
    # Attribute is overwritten below the class definition
    payload_too_large = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def incorrect_offset(cls, val):
        """
        Create an instance of this class set to the ``incorrect_offset`` tag
        with value ``val``.

        :param UploadSessionOffsetError val:
        :rtype: UploadSessionLookupError
        """
        return cls("incorrect_offset", val)

    def is_not_found(self):
        """
        Check if the union tag is ``not_found``.

        :rtype: bool
        """
        return self._tag == "not_found"

    def is_incorrect_offset(self):
        """
        Check if the union tag is ``incorrect_offset``.

        :rtype: bool
        """
        return self._tag == "incorrect_offset"

    def is_closed(self):
        """
        Check if the union tag is ``closed``.

        :rtype: bool
        """
        return self._tag == "closed"

    def is_not_closed(self):
        """
        Check if the union tag is ``not_closed``.

        :rtype: bool
        """
        return self._tag == "not_closed"

    def is_too_large(self):
        """
        Check if the union tag is ``too_large``.

        :rtype: bool
        """
        return self._tag == "too_large"

    def is_concurrent_session_invalid_offset(self):
        """
        Check if the union tag is ``concurrent_session_invalid_offset``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_invalid_offset"

    def is_concurrent_session_invalid_data_size(self):
        """
        Check if the union tag is ``concurrent_session_invalid_data_size``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_invalid_data_size"

    def is_payload_too_large(self):
        """
        Check if the union tag is ``payload_too_large``.

        :rtype: bool
        """
        return self._tag == "payload_too_large"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_incorrect_offset(self):
        """
        The specified offset was incorrect. See the value for the correct
        offset. This error may occur when a previous request was received and
        processed successfully but the client did not receive the response, e.g.
        due to a network error.

        Only call this if :meth:`is_incorrect_offset` is true.

        :rtype: UploadSessionOffsetError
        """
        if not self.is_incorrect_offset():
            raise AttributeError("tag 'incorrect_offset' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionLookupError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionLookupError_validator = bv.Union(UploadSessionLookupError)


class UploadSessionOffsetError(bb.Struct):
    """
    :ivar UploadSessionOffsetError.correct_offset:
        The offset up to which data has been collected.
    """

    __slots__ = [
        "_correct_offset_value",
    ]

    _has_required_fields = True

    def __init__(self, correct_offset=None):
        self._correct_offset_value = bb.NOT_SET
        if correct_offset is not None:
            self.correct_offset = correct_offset

    # Instance attribute type: int (validator is set below)
    correct_offset = bb.Attribute("correct_offset")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionOffsetError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionOffsetError_validator = bv.Struct(UploadSessionOffsetError)


class UploadSessionStartArg(bb.Struct):
    """
    :ivar UploadSessionStartArg.close:
        If true, the current session will be closed, at which point you won't be
        able to call
        :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_append`
        anymore with the current session.
    :ivar UploadSessionStartArg.session_type:
        Type of upload session you want to start. If not specified, default is
        ``UploadSessionType.sequential``.
    :ivar UploadSessionStartArg.content_hash:
        A hash of the file content uploaded in this call. If provided and the
        uploaded content does not match this hash, an error will be returned.
        For more information see our `Content hash
        <https://www.dropbox.com/developers/reference/content-hash>`_ page.
    """

    __slots__ = [
        "_close_value",
        "_session_type_value",
        "_content_hash_value",
    ]

    _has_required_fields = False

    def __init__(self, close=None, session_type=None, content_hash=None):
        self._close_value = bb.NOT_SET
        self._session_type_value = bb.NOT_SET
        self._content_hash_value = bb.NOT_SET
        if close is not None:
            self.close = close
        if session_type is not None:
            self.session_type = session_type
        if content_hash is not None:
            self.content_hash = content_hash

    # Instance attribute type: bool (validator is set below)
    close = bb.Attribute("close")

    # Instance attribute type: UploadSessionType (validator is set below)
    session_type = bb.Attribute("session_type", nullable=True, user_defined=True)

    # Instance attribute type: str (validator is set below)
    content_hash = bb.Attribute("content_hash", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionStartArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionStartArg_validator = bv.Struct(UploadSessionStartArg)


class UploadSessionStartBatchArg(bb.Struct):
    """
    :ivar UploadSessionStartBatchArg.session_type:
        Type of upload session you want to start. If not specified, default is
        ``UploadSessionType.sequential``.
    :ivar UploadSessionStartBatchArg.num_sessions:
        The number of upload sessions to start.
    """

    __slots__ = [
        "_session_type_value",
        "_num_sessions_value",
    ]

    _has_required_fields = True

    def __init__(self, num_sessions=None, session_type=None):
        self._session_type_value = bb.NOT_SET
        self._num_sessions_value = bb.NOT_SET
        if session_type is not None:
            self.session_type = session_type
        if num_sessions is not None:
            self.num_sessions = num_sessions

    # Instance attribute type: UploadSessionType (validator is set below)
    session_type = bb.Attribute("session_type", nullable=True, user_defined=True)

    # Instance attribute type: int (validator is set below)
    num_sessions = bb.Attribute("num_sessions")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionStartBatchArg, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionStartBatchArg_validator = bv.Struct(UploadSessionStartBatchArg)


class UploadSessionStartBatchResult(bb.Struct):
    """
    :ivar UploadSessionStartBatchResult.session_ids:
        A List of unique identifiers for the upload session. Pass each
        session_id to
        :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_append` and
        :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_finish`.
    """

    __slots__ = [
        "_session_ids_value",
    ]

    _has_required_fields = True

    def __init__(self, session_ids=None):
        self._session_ids_value = bb.NOT_SET
        if session_ids is not None:
            self.session_ids = session_ids

    # Instance attribute type: list of [str] (validator is set below)
    session_ids = bb.Attribute("session_ids")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionStartBatchResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionStartBatchResult_validator = bv.Struct(UploadSessionStartBatchResult)


class UploadSessionStartError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar UploadSessionStartError.concurrent_session_data_not_allowed:
        Uploading data not allowed when starting concurrent upload session.
    :ivar UploadSessionStartError.concurrent_session_close_not_allowed:
        Can not start a closed concurrent upload session.
    :ivar UploadSessionStartError.payload_too_large:
        The request payload must be at most 150 MiB.
    :ivar UploadSessionStartError.content_hash_mismatch:
        The content received by the Dropbox server in this call does not match
        the provided content hash.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    concurrent_session_data_not_allowed = None
    # Attribute is overwritten below the class definition
    concurrent_session_close_not_allowed = None
    # Attribute is overwritten below the class definition
    payload_too_large = None
    # Attribute is overwritten below the class definition
    content_hash_mismatch = None
    # Attribute is overwritten below the class definition
    other = None

    def is_concurrent_session_data_not_allowed(self):
        """
        Check if the union tag is ``concurrent_session_data_not_allowed``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_data_not_allowed"

    def is_concurrent_session_close_not_allowed(self):
        """
        Check if the union tag is ``concurrent_session_close_not_allowed``.

        :rtype: bool
        """
        return self._tag == "concurrent_session_close_not_allowed"

    def is_payload_too_large(self):
        """
        Check if the union tag is ``payload_too_large``.

        :rtype: bool
        """
        return self._tag == "payload_too_large"

    def is_content_hash_mismatch(self):
        """
        Check if the union tag is ``content_hash_mismatch``.

        :rtype: bool
        """
        return self._tag == "content_hash_mismatch"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionStartError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionStartError_validator = bv.Union(UploadSessionStartError)


class UploadSessionStartResult(bb.Struct):
    """
    :ivar UploadSessionStartResult.session_id:
        A unique identifier for the upload session. Pass this to
        :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_append` and
        :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_finish`.
    """

    __slots__ = [
        "_session_id_value",
    ]

    _has_required_fields = True

    def __init__(self, session_id=None):
        self._session_id_value = bb.NOT_SET
        if session_id is not None:
            self.session_id = session_id

    # Instance attribute type: str (validator is set below)
    session_id = bb.Attribute("session_id")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionStartResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionStartResult_validator = bv.Struct(UploadSessionStartResult)


class UploadSessionType(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar UploadSessionType.sequential:
        Pieces of data are uploaded sequentially one after another. This is the
        default behavior.
    :ivar UploadSessionType.concurrent:
        Pieces of data can be uploaded in concurrent RPCs in any order.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    sequential = None
    # Attribute is overwritten below the class definition
    concurrent = None
    # Attribute is overwritten below the class definition
    other = None

    def is_sequential(self):
        """
        Check if the union tag is ``sequential``.

        :rtype: bool
        """
        return self._tag == "sequential"

    def is_concurrent(self):
        """
        Check if the union tag is ``concurrent``.

        :rtype: bool
        """
        return self._tag == "concurrent"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadSessionType, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadSessionType_validator = bv.Union(UploadSessionType)


class UploadWriteFailed(bb.Struct):
    """
    :ivar UploadWriteFailed.reason:
        The reason why the file couldn't be saved.
    :ivar UploadWriteFailed.upload_session_id:
        The upload session ID; data has already been uploaded to the
        corresponding upload session and this ID may be used to retry the commit
        with :meth:`dropbox.dropbox_client.Dropbox.files_upload_session_finish`.
    """

    __slots__ = [
        "_reason_value",
        "_upload_session_id_value",
    ]

    _has_required_fields = True

    def __init__(self, reason=None, upload_session_id=None):
        self._reason_value = bb.NOT_SET
        self._upload_session_id_value = bb.NOT_SET
        if reason is not None:
            self.reason = reason
        if upload_session_id is not None:
            self.upload_session_id = upload_session_id

    # Instance attribute type: WriteError (validator is set below)
    reason = bb.Attribute("reason", user_defined=True)

    # Instance attribute type: str (validator is set below)
    upload_session_id = bb.Attribute("upload_session_id")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UploadWriteFailed, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UploadWriteFailed_validator = bv.Struct(UploadWriteFailed)


class UserGeneratedTag(bb.Struct):
    __slots__ = [
        "_tag_text_value",
    ]

    _has_required_fields = True

    def __init__(self, tag_text=None):
        self._tag_text_value = bb.NOT_SET
        if tag_text is not None:
            self.tag_text = tag_text

    # Instance attribute type: str (validator is set below)
    tag_text = bb.Attribute("tag_text")

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(UserGeneratedTag, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


UserGeneratedTag_validator = bv.Struct(UserGeneratedTag)


class VideoMetadata(MediaMetadata):
    """
    Metadata for a video.

    :ivar VideoMetadata.duration:
        The duration of the video in milliseconds.
    """

    __slots__ = [
        "_duration_value",
    ]

    _has_required_fields = False

    def __init__(self, dimensions=None, location=None, time_taken=None, duration=None):
        super(VideoMetadata, self).__init__(dimensions, location, time_taken)
        self._duration_value = bb.NOT_SET
        if duration is not None:
            self.duration = duration

    # Instance attribute type: int (validator is set below)
    duration = bb.Attribute("duration", nullable=True)

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(VideoMetadata, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


VideoMetadata_validator = bv.Struct(VideoMetadata)


class WriteConflictError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar WriteConflictError.file:
        There's a file in the way.
    :ivar WriteConflictError.folder:
        There's a folder in the way.
    :ivar WriteConflictError.file_ancestor:
        There's a file at an ancestor path, so we couldn't create the required
        parent folders.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    file = None
    # Attribute is overwritten below the class definition
    folder = None
    # Attribute is overwritten below the class definition
    file_ancestor = None
    # Attribute is overwritten below the class definition
    other = None

    def is_file(self):
        """
        Check if the union tag is ``file``.

        :rtype: bool
        """
        return self._tag == "file"

    def is_folder(self):
        """
        Check if the union tag is ``folder``.

        :rtype: bool
        """
        return self._tag == "folder"

    def is_file_ancestor(self):
        """
        Check if the union tag is ``file_ancestor``.

        :rtype: bool
        """
        return self._tag == "file_ancestor"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(WriteConflictError, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


WriteConflictError_validator = bv.Union(WriteConflictError)


class WriteError(bb.Union):
    """
    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar WriteError.malformed_path:
        The given path does not satisfy the required path format. Please refer
        to the `Path formats documentation
        <https://www.dropbox.com/developers/documentation/http/documentation#path-formats>`_
        for more information.
    :vartype WriteError.malformed_path: Optional[str]
    :ivar WriteError.conflict:
        Couldn't write to the target path because there was something in the
        way.
    :vartype WriteError.conflict: WriteConflictError
    :ivar WriteError.no_write_permission:
        The user doesn't have permissions to write to the target location.
    :ivar WriteError.insufficient_space:
        The user doesn't have enough available space (bytes) to write more data.
    :ivar WriteError.disallowed_name:
        Dropbox will not save the file or folder because of its name.
    :ivar WriteError.team_folder:
        This endpoint cannot move or delete team folders.
    :ivar WriteError.operation_suppressed:
        This file operation is not allowed at this path.
    :ivar WriteError.too_many_write_operations:
        There are too many write operations in user's Dropbox. Please retry this
        request.
    :ivar WriteError.access_restricted:
        The user doesn't have permission to perform the action due to
        restrictions set by a team administrator
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    no_write_permission = None
    # Attribute is overwritten below the class definition
    insufficient_space = None
    # Attribute is overwritten below the class definition
    disallowed_name = None
    # Attribute is overwritten below the class definition
    team_folder = None
    # Attribute is overwritten below the class definition
    operation_suppressed = None
    # Attribute is overwritten below the class definition
    too_many_write_operations = None
    # Attribute is overwritten below the class definition
    access_restricted = None
    # Attribute is overwritten below the class definition
    other = None

    @classmethod
    def malformed_path(cls, val):
        """
        Create an instance of this class set to the ``malformed_path`` tag with
        value ``val``.

        :param Optional[str] val:
        :rtype: WriteError
        """
        return cls("malformed_path", val)

    @classmethod
    def conflict(cls, val):
        """
        Create an instance of this class set to the ``conflict`` tag with value
        ``val``.

        :param WriteConflictError val:
        :rtype: WriteError
        """
        return cls("conflict", val)

    def is_malformed_path(self):
        """
        Check if the union tag is ``malformed_path``.

        :rtype: bool
        """
        return self._tag == "malformed_path"

    def is_conflict(self):
        """
        Check if the union tag is ``conflict``.

        :rtype: bool
        """
        return self._tag == "conflict"

    def is_no_write_permission(self):
        """
        Check if the union tag is ``no_write_permission``.

        :rtype: bool
        """
        return self._tag == "no_write_permission"

    def is_insufficient_space(self):
        """
        Check if the union tag is ``insufficient_space``.

        :rtype: bool
        """
        return self._tag == "insufficient_space"

    def is_disallowed_name(self):
        """
        Check if the union tag is ``disallowed_name``.

        :rtype: bool
        """
        return self._tag == "disallowed_name"

    def is_team_folder(self):
        """
        Check if the union tag is ``team_folder``.

        :rtype: bool
        """
        return self._tag == "team_folder"

    def is_operation_suppressed(self):
        """
        Check if the union tag is ``operation_suppressed``.

        :rtype: bool
        """
        return self._tag == "operation_suppressed"

    def is_too_many_write_operations(self):
        """
        Check if the union tag is ``too_many_write_operations``.

        :rtype: bool
        """
        return self._tag == "too_many_write_operations"

    def is_access_restricted(self):
        """
        Check if the union tag is ``access_restricted``.

        :rtype: bool
        """
        return self._tag == "access_restricted"

    def is_other(self):
        """
        Check if the union tag is ``other``.

        :rtype: bool
        """
        return self._tag == "other"

    def get_malformed_path(self):
        """
        The given path does not satisfy the required path format. Please refer
        to the `Path formats documentation
        <https://www.dropbox.com/developers/documentation/http/documentation#path-formats>`_
        for more information.

        Only call this if :meth:`is_malformed_path` is true.

        :rtype: Optional[str]
        """
        if not self.is_malformed_path():
            raise AttributeError("tag 'malformed_path' not set")
        return self._value

    def get_conflict(self):
        """
        Couldn't write to the target path because there was something in the
        way.

        Only call this if :meth:`is_conflict` is true.

        :rtype: WriteConflictError
        """
        if not self.is_conflict():
            raise AttributeError("tag 'conflict' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(WriteError, self)._process_custom_annotations(annotation_type, field_path, processor)


WriteError_validator = bv.Union(WriteError)


class WriteMode(bb.Union):
    """
    Your intent when writing a file to some path. This is used to determine what
    constitutes a conflict and what the autorename strategy is. In some
    situations, the conflict behavior is identical: (a) If the target path
    doesn't refer to anything, the file is always written; no conflict. (b) If
    the target path refers to a folder, it's always a conflict. (c) If the
    target path refers to a file with identical contents, nothing gets written;
    no conflict. The conflict checking differs in the case where there's a file
    at the target path with contents different from the contents you're trying
    to write.

    This class acts as a tagged union. Only one of the ``is_*`` methods will
    return true. To get the associated value of a tag (if one exists), use the
    corresponding ``get_*`` method.

    :ivar WriteMode.add:
        Do not overwrite an existing file if there is a conflict. The autorename
        strategy is to append a number to the file name. For example,
        "document.txt" might become "document (2).txt".
    :ivar WriteMode.overwrite:
        Always overwrite the existing file. The autorename strategy is the same
        as it is for ``add``.
    :ivar WriteMode.update:
        Overwrite if the given "rev" matches the existing file's "rev". The
        supplied value should be the latest known "rev" of the file, for
        example, from :class:`FileMetadata`, from when the file was last
        downloaded by the app. This will cause the file on the Dropbox servers
        to be overwritten if the given "rev" matches the existing file's current
        "rev" on the Dropbox servers. The autorename strategy is to append the
        string "conflicted copy" to the file name. For example, "document.txt"
        might become "document (conflicted copy).txt" or "document (Panda's
        conflicted copy).txt".
    :vartype WriteMode.update: str
    """

    _catch_all = None
    # Attribute is overwritten below the class definition
    add = None
    # Attribute is overwritten below the class definition
    overwrite = None

    @classmethod
    def update(cls, val):
        """
        Create an instance of this class set to the ``update`` tag with value
        ``val``.

        :param str val:
        :rtype: WriteMode
        """
        return cls("update", val)

    def is_add(self):
        """
        Check if the union tag is ``add``.

        :rtype: bool
        """
        return self._tag == "add"

    def is_overwrite(self):
        """
        Check if the union tag is ``overwrite``.

        :rtype: bool
        """
        return self._tag == "overwrite"

    def is_update(self):
        """
        Check if the union tag is ``update``.

        :rtype: bool
        """
        return self._tag == "update"

    def get_update(self):
        """
        Overwrite if the given "rev" matches the existing file's "rev". The
        supplied value should be the latest known "rev" of the file, for
        example, from :class:`FileMetadata`, from when the file was last
        downloaded by the app. This will cause the file on the Dropbox servers
        to be overwritten if the given "rev" matches the existing file's current
        "rev" on the Dropbox servers. The autorename strategy is to append the
        string "conflicted copy" to the file name. For example, "document.txt"
        might become "document (conflicted copy).txt" or "document (Panda's
        conflicted copy).txt".

        Only call this if :meth:`is_update` is true.

        :rtype: str
        """
        if not self.is_update():
            raise AttributeError("tag 'update' not set")
        return self._value

    def _process_custom_annotations(self, annotation_type, field_path, processor):
        super(WriteMode, self)._process_custom_annotations(annotation_type, field_path, processor)


WriteMode_validator = bv.Union(WriteMode)

CopyBatchArg_validator = RelocationBatchArgBase_validator
CopyBatchArg = RelocationBatchArgBase
FileId_validator = bv.String(min_length=4, pattern="id:.+")
Id_validator = bv.String(min_length=1)
ListFolderCursor_validator = bv.String(min_length=1)
MalformedPathError_validator = bv.Nullable(bv.String())
Path_validator = bv.String(pattern="/(.|[\\r\\n])*")
PathOrId_validator = bv.String(pattern="/(.|[\\r\\n])*|id:.*|(ns:[0-9]+(/(.|[\\r\\n])*)?)")
PathR_validator = bv.String(pattern="(/(.|[\\r\\n])*)?|(ns:[0-9]+(/(.|[\\r\\n])*)?)")
PathROrId_validator = bv.String(pattern="(/(.|[\\r\\n])*)?|id:.*|(ns:[0-9]+(/(.|[\\r\\n])*)?)")
ReadPath_validator = bv.String(
    pattern="(/(.|[\\r\\n])*|id:.*)|(rev:[0-9a-f]{9,})|(ns:[0-9]+(/(.|[\\r\\n])*)?)"
)
Rev_validator = bv.String(min_length=9, pattern="[0-9a-f]+")
SearchV2Cursor_validator = bv.String(min_length=1)
Sha256HexHash_validator = bv.String(min_length=64, max_length=64)
SharedLinkUrl_validator = bv.String()
TagText_validator = bv.String(min_length=1, max_length=32, pattern="[\\w]+")
WritePath_validator = bv.String(pattern="(/(.|[\\r\\n])*)|(ns:[0-9]+(/(.|[\\r\\n])*)?)")
WritePathOrId_validator = bv.String(pattern="(/(.|[\\r\\n])*)|(ns:[0-9]+(/(.|[\\r\\n])*)?)|(id:.*)")
AddTagArg.path.validator = Path_validator
AddTagArg.tag_text.validator = TagText_validator
AddTagArg._all_field_names_ = set(
    [
        "path",
        "tag_text",
    ]
)
AddTagArg._all_fields_ = [
    ("path", AddTagArg.path.validator),
    ("tag_text", AddTagArg.tag_text.validator),
]

BaseTagError._path_validator = LookupError_validator
BaseTagError._other_validator = bv.Void()
BaseTagError._tagmap = {
    "path": BaseTagError._path_validator,
    "other": BaseTagError._other_validator,
}

BaseTagError.other = BaseTagError("other")

AddTagError._too_many_tags_validator = bv.Void()
AddTagError._tagmap = {
    "too_many_tags": AddTagError._too_many_tags_validator,
}
AddTagError._tagmap.update(BaseTagError._tagmap)

AddTagError.too_many_tags = AddTagError("too_many_tags")

GetMetadataArg.path.validator = ReadPath_validator
GetMetadataArg.include_media_info.validator = bv.Boolean()
GetMetadataArg.include_deleted.validator = bv.Boolean()
GetMetadataArg.include_has_explicit_shared_members.validator = bv.Boolean()
GetMetadataArg.include_property_groups.validator = bv.Nullable(
    file_properties.TemplateFilterBase_validator
)
GetMetadataArg._all_field_names_ = set(
    [
        "path",
        "include_media_info",
        "include_deleted",
        "include_has_explicit_shared_members",
        "include_property_groups",
    ]
)
GetMetadataArg._all_fields_ = [
    ("path", GetMetadataArg.path.validator),
    ("include_media_info", GetMetadataArg.include_media_info.validator),
    ("include_deleted", GetMetadataArg.include_deleted.validator),
    (
        "include_has_explicit_shared_members",
        GetMetadataArg.include_has_explicit_shared_members.validator,
    ),
    ("include_property_groups", GetMetadataArg.include_property_groups.validator),
]

AlphaGetMetadataArg.include_property_templates.validator = bv.Nullable(
    bv.List(file_properties.TemplateId_validator)
)
AlphaGetMetadataArg._all_field_names_ = GetMetadataArg._all_field_names_.union(
    set(["include_property_templates"])
)
AlphaGetMetadataArg._all_fields_ = GetMetadataArg._all_fields_ + [
    (
        "include_property_templates",
        AlphaGetMetadataArg.include_property_templates.validator,
    )
]

GetMetadataError._path_validator = LookupError_validator
GetMetadataError._tagmap = {
    "path": GetMetadataError._path_validator,
}

AlphaGetMetadataError._properties_error_validator = file_properties.LookUpPropertiesError_validator
AlphaGetMetadataError._tagmap = {
    "properties_error": AlphaGetMetadataError._properties_error_validator,
}
AlphaGetMetadataError._tagmap.update(GetMetadataError._tagmap)

CommitInfo.path.validator = WritePathOrId_validator
CommitInfo.mode.validator = WriteMode_validator
CommitInfo.autorename.validator = bv.Boolean()
CommitInfo.client_modified.validator = bv.Nullable(common.DropboxTimestamp_validator)
CommitInfo.mute.validator = bv.Boolean()
CommitInfo.property_groups.validator = bv.Nullable(bv.List(file_properties.PropertyGroup_validator))
CommitInfo.strict_conflict.validator = bv.Boolean()
CommitInfo._all_field_names_ = set(
    [
        "path",
        "mode",
        "autorename",
        "client_modified",
        "mute",
        "property_groups",
        "strict_conflict",
    ]
)
CommitInfo._all_fields_ = [
    ("path", CommitInfo.path.validator),
    ("mode", CommitInfo.mode.validator),
    ("autorename", CommitInfo.autorename.validator),
    ("client_modified", CommitInfo.client_modified.validator),
    ("mute", CommitInfo.mute.validator),
    ("property_groups", CommitInfo.property_groups.validator),
    ("strict_conflict", CommitInfo.strict_conflict.validator),
]

ContentSyncSetting.id.validator = FileId_validator
ContentSyncSetting.sync_setting.validator = SyncSetting_validator
ContentSyncSetting._all_field_names_ = set(
    [
        "id",
        "sync_setting",
    ]
)
ContentSyncSetting._all_fields_ = [
    ("id", ContentSyncSetting.id.validator),
    ("sync_setting", ContentSyncSetting.sync_setting.validator),
]

ContentSyncSettingArg.id.validator = FileId_validator
ContentSyncSettingArg.sync_setting.validator = SyncSettingArg_validator
ContentSyncSettingArg._all_field_names_ = set(
    [
        "id",
        "sync_setting",
    ]
)
ContentSyncSettingArg._all_fields_ = [
    ("id", ContentSyncSettingArg.id.validator),
    ("sync_setting", ContentSyncSettingArg.sync_setting.validator),
]

CreateFolderArg.path.validator = WritePath_validator
CreateFolderArg.autorename.validator = bv.Boolean()
CreateFolderArg._all_field_names_ = set(
    [
        "path",
        "autorename",
    ]
)
CreateFolderArg._all_fields_ = [
    ("path", CreateFolderArg.path.validator),
    ("autorename", CreateFolderArg.autorename.validator),
]

CreateFolderBatchArg.paths.validator = bv.List(WritePath_validator, max_items=10000)
CreateFolderBatchArg.autorename.validator = bv.Boolean()
CreateFolderBatchArg.force_async.validator = bv.Boolean()
CreateFolderBatchArg._all_field_names_ = set(
    [
        "paths",
        "autorename",
        "force_async",
    ]
)
CreateFolderBatchArg._all_fields_ = [
    ("paths", CreateFolderBatchArg.paths.validator),
    ("autorename", CreateFolderBatchArg.autorename.validator),
    ("force_async", CreateFolderBatchArg.force_async.validator),
]

CreateFolderBatchError._too_many_files_validator = bv.Void()
CreateFolderBatchError._other_validator = bv.Void()
CreateFolderBatchError._tagmap = {
    "too_many_files": CreateFolderBatchError._too_many_files_validator,
    "other": CreateFolderBatchError._other_validator,
}

CreateFolderBatchError.too_many_files = CreateFolderBatchError("too_many_files")
CreateFolderBatchError.other = CreateFolderBatchError("other")

CreateFolderBatchJobStatus._complete_validator = CreateFolderBatchResult_validator
CreateFolderBatchJobStatus._failed_validator = CreateFolderBatchError_validator
CreateFolderBatchJobStatus._other_validator = bv.Void()
CreateFolderBatchJobStatus._tagmap = {
    "complete": CreateFolderBatchJobStatus._complete_validator,
    "failed": CreateFolderBatchJobStatus._failed_validator,
    "other": CreateFolderBatchJobStatus._other_validator,
}
CreateFolderBatchJobStatus._tagmap.update(async_.PollResultBase._tagmap)

CreateFolderBatchJobStatus.other = CreateFolderBatchJobStatus("other")

CreateFolderBatchLaunch._complete_validator = CreateFolderBatchResult_validator
CreateFolderBatchLaunch._other_validator = bv.Void()
CreateFolderBatchLaunch._tagmap = {
    "complete": CreateFolderBatchLaunch._complete_validator,
    "other": CreateFolderBatchLaunch._other_validator,
}
CreateFolderBatchLaunch._tagmap.update(async_.LaunchResultBase._tagmap)

CreateFolderBatchLaunch.other = CreateFolderBatchLaunch("other")

FileOpsResult._all_field_names_ = set([])
FileOpsResult._all_fields_ = []

CreateFolderBatchResult.entries.validator = bv.List(CreateFolderBatchResultEntry_validator)
CreateFolderBatchResult._all_field_names_ = FileOpsResult._all_field_names_.union(set(["entries"]))
CreateFolderBatchResult._all_fields_ = FileOpsResult._all_fields_ + [
    ("entries", CreateFolderBatchResult.entries.validator)
]

CreateFolderBatchResultEntry._success_validator = CreateFolderEntryResult_validator
CreateFolderBatchResultEntry._failure_validator = CreateFolderEntryError_validator
CreateFolderBatchResultEntry._tagmap = {
    "success": CreateFolderBatchResultEntry._success_validator,
    "failure": CreateFolderBatchResultEntry._failure_validator,
}

CreateFolderEntryError._path_validator = WriteError_validator
CreateFolderEntryError._other_validator = bv.Void()
CreateFolderEntryError._tagmap = {
    "path": CreateFolderEntryError._path_validator,
    "other": CreateFolderEntryError._other_validator,
}

CreateFolderEntryError.other = CreateFolderEntryError("other")

CreateFolderEntryResult.metadata.validator = FolderMetadata_validator
CreateFolderEntryResult._all_field_names_ = set(["metadata"])
CreateFolderEntryResult._all_fields_ = [("metadata", CreateFolderEntryResult.metadata.validator)]

CreateFolderError._path_validator = WriteError_validator
CreateFolderError._tagmap = {
    "path": CreateFolderError._path_validator,
}

CreateFolderResult.metadata.validator = FolderMetadata_validator
CreateFolderResult._all_field_names_ = FileOpsResult._all_field_names_.union(set(["metadata"]))
CreateFolderResult._all_fields_ = FileOpsResult._all_fields_ + [
    ("metadata", CreateFolderResult.metadata.validator)
]

DeleteArg.path.validator = WritePathOrId_validator
DeleteArg.parent_rev.validator = bv.Nullable(Rev_validator)
DeleteArg._all_field_names_ = set(
    [
        "path",
        "parent_rev",
    ]
)
DeleteArg._all_fields_ = [
    ("path", DeleteArg.path.validator),
    ("parent_rev", DeleteArg.parent_rev.validator),
]

DeleteBatchArg.entries.validator = bv.List(DeleteArg_validator, max_items=1000)
DeleteBatchArg._all_field_names_ = set(["entries"])
DeleteBatchArg._all_fields_ = [("entries", DeleteBatchArg.entries.validator)]

DeleteBatchError._too_many_write_operations_validator = bv.Void()
DeleteBatchError._other_validator = bv.Void()
DeleteBatchError._tagmap = {
    "too_many_write_operations": DeleteBatchError._too_many_write_operations_validator,
    "other": DeleteBatchError._other_validator,
}

DeleteBatchError.too_many_write_operations = DeleteBatchError("too_many_write_operations")
DeleteBatchError.other = DeleteBatchError("other")

DeleteBatchJobStatus._complete_validator = DeleteBatchResult_validator
DeleteBatchJobStatus._failed_validator = DeleteBatchError_validator
DeleteBatchJobStatus._other_validator = bv.Void()
DeleteBatchJobStatus._tagmap = {
    "complete": DeleteBatchJobStatus._complete_validator,
    "failed": DeleteBatchJobStatus._failed_validator,
    "other": DeleteBatchJobStatus._other_validator,
}
DeleteBatchJobStatus._tagmap.update(async_.PollResultBase._tagmap)

DeleteBatchJobStatus.other = DeleteBatchJobStatus("other")

DeleteBatchLaunch._complete_validator = DeleteBatchResult_validator
DeleteBatchLaunch._other_validator = bv.Void()
DeleteBatchLaunch._tagmap = {
    "complete": DeleteBatchLaunch._complete_validator,
    "other": DeleteBatchLaunch._other_validator,
}
DeleteBatchLaunch._tagmap.update(async_.LaunchResultBase._tagmap)

DeleteBatchLaunch.other = DeleteBatchLaunch("other")

DeleteBatchResult.entries.validator = bv.List(DeleteBatchResultEntry_validator)
DeleteBatchResult._all_field_names_ = FileOpsResult._all_field_names_.union(set(["entries"]))
DeleteBatchResult._all_fields_ = FileOpsResult._all_fields_ + [
    ("entries", DeleteBatchResult.entries.validator)
]

DeleteBatchResultData.metadata.validator = Metadata_validator
DeleteBatchResultData._all_field_names_ = set(["metadata"])
DeleteBatchResultData._all_fields_ = [("metadata", DeleteBatchResultData.metadata.validator)]

DeleteBatchResultEntry._success_validator = DeleteBatchResultData_validator
DeleteBatchResultEntry._failure_validator = DeleteError_validator
DeleteBatchResultEntry._tagmap = {
    "success": DeleteBatchResultEntry._success_validator,
    "failure": DeleteBatchResultEntry._failure_validator,
}

DeleteError._path_lookup_validator = LookupError_validator
DeleteError._path_write_validator = WriteError_validator
DeleteError._too_many_write_operations_validator = bv.Void()
DeleteError._too_many_files_validator = bv.Void()
DeleteError._other_validator = bv.Void()
DeleteError._tagmap = {
    "path_lookup": DeleteError._path_lookup_validator,
    "path_write": DeleteError._path_write_validator,
    "too_many_write_operations": DeleteError._too_many_write_operations_validator,
    "too_many_files": DeleteError._too_many_files_validator,
    "other": DeleteError._other_validator,
}

DeleteError.too_many_write_operations = DeleteError("too_many_write_operations")
DeleteError.too_many_files = DeleteError("too_many_files")
DeleteError.other = DeleteError("other")

DeleteResult.metadata.validator = Metadata_validator
DeleteResult._all_field_names_ = FileOpsResult._all_field_names_.union(set(["metadata"]))
DeleteResult._all_fields_ = FileOpsResult._all_fields_ + [
    ("metadata", DeleteResult.metadata.validator)
]

Metadata.name.validator = bv.String()
Metadata.path_lower.validator = bv.Nullable(bv.String())
Metadata.path_display.validator = bv.Nullable(bv.String())
Metadata.parent_shared_folder_id.validator = bv.Nullable(common.SharedFolderId_validator)
Metadata.preview_url.validator = bv.Nullable(bv.String())
Metadata._field_names_ = set(
    [
        "name",
        "path_lower",
        "path_display",
        "parent_shared_folder_id",
        "preview_url",
    ]
)
Metadata._all_field_names_ = Metadata._field_names_
Metadata._fields_ = [
    ("name", Metadata.name.validator),
    ("path_lower", Metadata.path_lower.validator),
    ("path_display", Metadata.path_display.validator),
    ("parent_shared_folder_id", Metadata.parent_shared_folder_id.validator),
    ("preview_url", Metadata.preview_url.validator),
]
Metadata._all_fields_ = Metadata._fields_

Metadata._tag_to_subtype_ = {
    ("file",): FileMetadata_validator,
    ("folder",): FolderMetadata_validator,
    ("deleted",): DeletedMetadata_validator,
}
Metadata._pytype_to_tag_and_subtype_ = {
    FileMetadata: (("file",), FileMetadata_validator),
    FolderMetadata: (("folder",), FolderMetadata_validator),
    DeletedMetadata: (("deleted",), DeletedMetadata_validator),
}
Metadata._is_catch_all_ = False

DeletedMetadata.is_restorable.validator = bv.Nullable(bv.Boolean())
DeletedMetadata._field_names_ = set(["is_restorable"])
DeletedMetadata._all_field_names_ = Metadata._all_field_names_.union(DeletedMetadata._field_names_)
DeletedMetadata._fields_ = [("is_restorable", DeletedMetadata.is_restorable.validator)]
DeletedMetadata._all_fields_ = Metadata._all_fields_ + DeletedMetadata._fields_

Dimensions.height.validator = bv.UInt64()
Dimensions.width.validator = bv.UInt64()
Dimensions._all_field_names_ = set(
    [
        "height",
        "width",
    ]
)
Dimensions._all_fields_ = [
    ("height", Dimensions.height.validator),
    ("width", Dimensions.width.validator),
]

DownloadArg.path.validator = ReadPath_validator
DownloadArg.rev.validator = bv.Nullable(Rev_validator)
DownloadArg._all_field_names_ = set(
    [
        "path",
        "rev",
    ]
)
DownloadArg._all_fields_ = [
    ("path", DownloadArg.path.validator),
    ("rev", DownloadArg.rev.validator),
]

DownloadError._path_validator = LookupError_validator
DownloadError._unsupported_file_validator = bv.Void()
DownloadError._other_validator = bv.Void()
DownloadError._tagmap = {
    "path": DownloadError._path_validator,
    "unsupported_file": DownloadError._unsupported_file_validator,
    "other": DownloadError._other_validator,
}

DownloadError.unsupported_file = DownloadError("unsupported_file")
DownloadError.other = DownloadError("other")

DownloadZipArg.path.validator = ReadPath_validator
DownloadZipArg._all_field_names_ = set(["path"])
DownloadZipArg._all_fields_ = [("path", DownloadZipArg.path.validator)]

DownloadZipError._path_validator = LookupError_validator
DownloadZipError._too_large_validator = bv.Void()
DownloadZipError._too_many_files_validator = bv.Void()
DownloadZipError._other_validator = bv.Void()
DownloadZipError._tagmap = {
    "path": DownloadZipError._path_validator,
    "too_large": DownloadZipError._too_large_validator,
    "too_many_files": DownloadZipError._too_many_files_validator,
    "other": DownloadZipError._other_validator,
}

DownloadZipError.too_large = DownloadZipError("too_large")
DownloadZipError.too_many_files = DownloadZipError("too_many_files")
DownloadZipError.other = DownloadZipError("other")

DownloadZipResult.metadata.validator = FolderMetadata_validator
DownloadZipResult._all_field_names_ = set(["metadata"])
DownloadZipResult._all_fields_ = [("metadata", DownloadZipResult.metadata.validator)]

ExportArg.path.validator = ReadPath_validator
ExportArg.export_format.validator = bv.Nullable(bv.String())
ExportArg._all_field_names_ = set(
    [
        "path",
        "export_format",
    ]
)
ExportArg._all_fields_ = [
    ("path", ExportArg.path.validator),
    ("export_format", ExportArg.export_format.validator),
]

ExportError._path_validator = LookupError_validator
ExportError._non_exportable_validator = bv.Void()
ExportError._invalid_export_format_validator = bv.Void()
ExportError._retry_error_validator = bv.Void()
ExportError._other_validator = bv.Void()
ExportError._tagmap = {
    "path": ExportError._path_validator,
    "non_exportable": ExportError._non_exportable_validator,
    "invalid_export_format": ExportError._invalid_export_format_validator,
    "retry_error": ExportError._retry_error_validator,
    "other": ExportError._other_validator,
}

ExportError.non_exportable = ExportError("non_exportable")
ExportError.invalid_export_format = ExportError("invalid_export_format")
ExportError.retry_error = ExportError("retry_error")
ExportError.other = ExportError("other")

ExportInfo.export_as.validator = bv.Nullable(bv.String())
ExportInfo.export_options.validator = bv.Nullable(bv.List(bv.String()))
ExportInfo._all_field_names_ = set(
    [
        "export_as",
        "export_options",
    ]
)
ExportInfo._all_fields_ = [
    ("export_as", ExportInfo.export_as.validator),
    ("export_options", ExportInfo.export_options.validator),
]

ExportMetadata.name.validator = bv.String()
ExportMetadata.size.validator = bv.UInt64()
ExportMetadata.export_hash.validator = bv.Nullable(Sha256HexHash_validator)
ExportMetadata.paper_revision.validator = bv.Nullable(bv.Int64())
ExportMetadata._all_field_names_ = set(
    [
        "name",
        "size",
        "export_hash",
        "paper_revision",
    ]
)
ExportMetadata._all_fields_ = [
    ("name", ExportMetadata.name.validator),
    ("size", ExportMetadata.size.validator),
    ("export_hash", ExportMetadata.export_hash.validator),
    ("paper_revision", ExportMetadata.paper_revision.validator),
]

ExportResult.export_metadata.validator = ExportMetadata_validator
ExportResult.file_metadata.validator = FileMetadata_validator
ExportResult._all_field_names_ = set(
    [
        "export_metadata",
        "file_metadata",
    ]
)
ExportResult._all_fields_ = [
    ("export_metadata", ExportResult.export_metadata.validator),
    ("file_metadata", ExportResult.file_metadata.validator),
]

FileCategory._image_validator = bv.Void()
FileCategory._document_validator = bv.Void()
FileCategory._pdf_validator = bv.Void()
FileCategory._spreadsheet_validator = bv.Void()
FileCategory._presentation_validator = bv.Void()
FileCategory._audio_validator = bv.Void()
FileCategory._video_validator = bv.Void()
FileCategory._folder_validator = bv.Void()
FileCategory._paper_validator = bv.Void()
FileCategory._others_validator = bv.Void()
FileCategory._other_validator = bv.Void()
FileCategory._tagmap = {
    "image": FileCategory._image_validator,
    "document": FileCategory._document_validator,
    "pdf": FileCategory._pdf_validator,
    "spreadsheet": FileCategory._spreadsheet_validator,
    "presentation": FileCategory._presentation_validator,
    "audio": FileCategory._audio_validator,
    "video": FileCategory._video_validator,
    "folder": FileCategory._folder_validator,
    "paper": FileCategory._paper_validator,
    "others": FileCategory._others_validator,
    "other": FileCategory._other_validator,
}

FileCategory.image = FileCategory("image")
FileCategory.document = FileCategory("document")
FileCategory.pdf = FileCategory("pdf")
FileCategory.spreadsheet = FileCategory("spreadsheet")
FileCategory.presentation = FileCategory("presentation")
FileCategory.audio = FileCategory("audio")
FileCategory.video = FileCategory("video")
FileCategory.folder = FileCategory("folder")
FileCategory.paper = FileCategory("paper")
FileCategory.others = FileCategory("others")
FileCategory.other = FileCategory("other")

FileLock.content.validator = FileLockContent_validator
FileLock._all_field_names_ = set(["content"])
FileLock._all_fields_ = [("content", FileLock.content.validator)]

FileLockContent._unlocked_validator = bv.Void()
FileLockContent._single_user_validator = SingleUserLock_validator
FileLockContent._other_validator = bv.Void()
FileLockContent._tagmap = {
    "unlocked": FileLockContent._unlocked_validator,
    "single_user": FileLockContent._single_user_validator,
    "other": FileLockContent._other_validator,
}

FileLockContent.unlocked = FileLockContent("unlocked")
FileLockContent.other = FileLockContent("other")

FileLockMetadata.is_lockholder.validator = bv.Nullable(bv.Boolean())
FileLockMetadata.lockholder_name.validator = bv.Nullable(bv.String())
FileLockMetadata.lockholder_account_id.validator = bv.Nullable(users_common.AccountId_validator)
FileLockMetadata.created.validator = bv.Nullable(common.DropboxTimestamp_validator)
FileLockMetadata._all_field_names_ = set(
    [
        "is_lockholder",
        "lockholder_name",
        "lockholder_account_id",
        "created",
    ]
)
FileLockMetadata._all_fields_ = [
    ("is_lockholder", FileLockMetadata.is_lockholder.validator),
    ("lockholder_name", FileLockMetadata.lockholder_name.validator),
    ("lockholder_account_id", FileLockMetadata.lockholder_account_id.validator),
    ("created", FileLockMetadata.created.validator),
]

FileMetadata.id.validator = Id_validator
FileMetadata.client_modified.validator = common.DropboxTimestamp_validator
FileMetadata.server_modified.validator = common.DropboxTimestamp_validator
FileMetadata.rev.validator = Rev_validator
FileMetadata.size.validator = bv.UInt64()
FileMetadata.media_info.validator = bv.Nullable(MediaInfo_validator)
FileMetadata.symlink_info.validator = bv.Nullable(SymlinkInfo_validator)
FileMetadata.sharing_info.validator = bv.Nullable(FileSharingInfo_validator)
FileMetadata.is_downloadable.validator = bv.Boolean()
FileMetadata.export_info.validator = bv.Nullable(ExportInfo_validator)
FileMetadata.property_groups.validator = bv.Nullable(
    bv.List(file_properties.PropertyGroup_validator)
)
FileMetadata.has_explicit_shared_members.validator = bv.Nullable(bv.Boolean())
FileMetadata.content_hash.validator = bv.Nullable(Sha256HexHash_validator)
FileMetadata.file_lock_info.validator = bv.Nullable(FileLockMetadata_validator)
FileMetadata.is_restorable.validator = bv.Nullable(bv.Boolean())
FileMetadata._field_names_ = set(
    [
        "id",
        "client_modified",
        "server_modified",
        "rev",
        "size",
        "media_info",
        "symlink_info",
        "sharing_info",
        "is_downloadable",
        "export_info",
        "property_groups",
        "has_explicit_shared_members",
        "content_hash",
        "file_lock_info",
        "is_restorable",
    ]
)
FileMetadata._all_field_names_ = Metadata._all_field_names_.union(FileMetadata._field_names_)
FileMetadata._fields_ = [
    ("id", FileMetadata.id.validator),
    ("client_modified", FileMetadata.client_modified.validator),
    ("server_modified", FileMetadata.server_modified.validator),
    ("rev", FileMetadata.rev.validator),
    ("size", FileMetadata.size.validator),
    ("media_info", FileMetadata.media_info.validator),
    ("symlink_info", FileMetadata.symlink_info.validator),
    ("sharing_info", FileMetadata.sharing_info.validator),
    ("is_downloadable", FileMetadata.is_downloadable.validator),
    ("export_info", FileMetadata.export_info.validator),
    ("property_groups", FileMetadata.property_groups.validator),
    ("has_explicit_shared_members", FileMetadata.has_explicit_shared_members.validator),
    ("content_hash", FileMetadata.content_hash.validator),
    ("file_lock_info", FileMetadata.file_lock_info.validator),
    ("is_restorable", FileMetadata.is_restorable.validator),
]
FileMetadata._all_fields_ = Metadata._all_fields_ + FileMetadata._fields_

SharingInfo.read_only.validator = bv.Boolean()
SharingInfo._all_field_names_ = set(["read_only"])
SharingInfo._all_fields_ = [("read_only", SharingInfo.read_only.validator)]

FileSharingInfo.parent_shared_folder_id.validator = common.SharedFolderId_validator
FileSharingInfo.modified_by.validator = bv.Nullable(users_common.AccountId_validator)
FileSharingInfo._all_field_names_ = SharingInfo._all_field_names_.union(
    set(
        [
            "parent_shared_folder_id",
            "modified_by",
        ]
    )
)
FileSharingInfo._all_fields_ = SharingInfo._all_fields_ + [
    ("parent_shared_folder_id", FileSharingInfo.parent_shared_folder_id.validator),
    ("modified_by", FileSharingInfo.modified_by.validator),
]

FileStatus._active_validator = bv.Void()
FileStatus._deleted_validator = bv.Void()
FileStatus._other_validator = bv.Void()
FileStatus._tagmap = {
    "active": FileStatus._active_validator,
    "deleted": FileStatus._deleted_validator,
    "other": FileStatus._other_validator,
}

FileStatus.active = FileStatus("active")
FileStatus.deleted = FileStatus("deleted")
FileStatus.other = FileStatus("other")

FolderMetadata.id.validator = Id_validator
FolderMetadata.shared_folder_id.validator = bv.Nullable(common.SharedFolderId_validator)
FolderMetadata.sharing_info.validator = bv.Nullable(FolderSharingInfo_validator)
FolderMetadata.property_groups.validator = bv.Nullable(
    bv.List(file_properties.PropertyGroup_validator)
)
FolderMetadata._field_names_ = set(
    [
        "id",
        "shared_folder_id",
        "sharing_info",
        "property_groups",
    ]
)
FolderMetadata._all_field_names_ = Metadata._all_field_names_.union(FolderMetadata._field_names_)
FolderMetadata._fields_ = [
    ("id", FolderMetadata.id.validator),
    ("shared_folder_id", FolderMetadata.shared_folder_id.validator),
    ("sharing_info", FolderMetadata.sharing_info.validator),
    ("property_groups", FolderMetadata.property_groups.validator),
]
FolderMetadata._all_fields_ = Metadata._all_fields_ + FolderMetadata._fields_

FolderSharingInfo.parent_shared_folder_id.validator = bv.Nullable(common.SharedFolderId_validator)
FolderSharingInfo.shared_folder_id.validator = bv.Nullable(common.SharedFolderId_validator)
FolderSharingInfo.traverse_only.validator = bv.Boolean()
FolderSharingInfo.no_access.validator = bv.Boolean()
FolderSharingInfo._all_field_names_ = SharingInfo._all_field_names_.union(
    set(
        [
            "parent_shared_folder_id",
            "shared_folder_id",
            "traverse_only",
            "no_access",
        ]
    )
)
FolderSharingInfo._all_fields_ = SharingInfo._all_fields_ + [
    ("parent_shared_folder_id", FolderSharingInfo.parent_shared_folder_id.validator),
    ("shared_folder_id", FolderSharingInfo.shared_folder_id.validator),
    ("traverse_only", FolderSharingInfo.traverse_only.validator),
    ("no_access", FolderSharingInfo.no_access.validator),
]

GetCopyReferenceArg.path.validator = ReadPath_validator
GetCopyReferenceArg._all_field_names_ = set(["path"])
GetCopyReferenceArg._all_fields_ = [("path", GetCopyReferenceArg.path.validator)]

GetCopyReferenceError._path_validator = LookupError_validator
GetCopyReferenceError._other_validator = bv.Void()
GetCopyReferenceError._tagmap = {
    "path": GetCopyReferenceError._path_validator,
    "other": GetCopyReferenceError._other_validator,
}

GetCopyReferenceError.other = GetCopyReferenceError("other")

GetCopyReferenceResult.metadata.validator = Metadata_validator
GetCopyReferenceResult.copy_reference.validator = bv.String()
GetCopyReferenceResult.expires.validator = common.DropboxTimestamp_validator
GetCopyReferenceResult._all_field_names_ = set(
    [
        "metadata",
        "copy_reference",
        "expires",
    ]
)
GetCopyReferenceResult._all_fields_ = [
    ("metadata", GetCopyReferenceResult.metadata.validator),
    ("copy_reference", GetCopyReferenceResult.copy_reference.validator),
    ("expires", GetCopyReferenceResult.expires.validator),
]

GetTagsArg.paths.validator = bv.List(Path_validator)
GetTagsArg._all_field_names_ = set(["paths"])
GetTagsArg._all_fields_ = [("paths", GetTagsArg.paths.validator)]

GetTagsResult.paths_to_tags.validator = bv.List(PathToTags_validator)
GetTagsResult._all_field_names_ = set(["paths_to_tags"])
GetTagsResult._all_fields_ = [("paths_to_tags", GetTagsResult.paths_to_tags.validator)]

GetTemporaryLinkArg.path.validator = ReadPath_validator
GetTemporaryLinkArg._all_field_names_ = set(["path"])
GetTemporaryLinkArg._all_fields_ = [("path", GetTemporaryLinkArg.path.validator)]

GetTemporaryLinkError._path_validator = LookupError_validator
GetTemporaryLinkError._email_not_verified_validator = bv.Void()
GetTemporaryLinkError._unsupported_file_validator = bv.Void()
GetTemporaryLinkError._not_allowed_validator = bv.Void()
GetTemporaryLinkError._other_validator = bv.Void()
GetTemporaryLinkError._tagmap = {
    "path": GetTemporaryLinkError._path_validator,
    "email_not_verified": GetTemporaryLinkError._email_not_verified_validator,
    "unsupported_file": GetTemporaryLinkError._unsupported_file_validator,
    "not_allowed": GetTemporaryLinkError._not_allowed_validator,
    "other": GetTemporaryLinkError._other_validator,
}

GetTemporaryLinkError.email_not_verified = GetTemporaryLinkError("email_not_verified")
GetTemporaryLinkError.unsupported_file = GetTemporaryLinkError("unsupported_file")
GetTemporaryLinkError.not_allowed = GetTemporaryLinkError("not_allowed")
GetTemporaryLinkError.other = GetTemporaryLinkError("other")

GetTemporaryLinkResult.metadata.validator = FileMetadata_validator
GetTemporaryLinkResult.link.validator = bv.String()
GetTemporaryLinkResult._all_field_names_ = set(
    [
        "metadata",
        "link",
    ]
)
GetTemporaryLinkResult._all_fields_ = [
    ("metadata", GetTemporaryLinkResult.metadata.validator),
    ("link", GetTemporaryLinkResult.link.validator),
]

GetTemporaryUploadLinkArg.commit_info.validator = CommitInfo_validator
GetTemporaryUploadLinkArg.duration.validator = bv.Float64(min_value=60.0, max_value=14400.0)
GetTemporaryUploadLinkArg._all_field_names_ = set(
    [
        "commit_info",
        "duration",
    ]
)
GetTemporaryUploadLinkArg._all_fields_ = [
    ("commit_info", GetTemporaryUploadLinkArg.commit_info.validator),
    ("duration", GetTemporaryUploadLinkArg.duration.validator),
]

GetTemporaryUploadLinkResult.link.validator = bv.String()
GetTemporaryUploadLinkResult._all_field_names_ = set(["link"])
GetTemporaryUploadLinkResult._all_fields_ = [("link", GetTemporaryUploadLinkResult.link.validator)]

GetThumbnailBatchArg.entries.validator = bv.List(ThumbnailArg_validator)
GetThumbnailBatchArg._all_field_names_ = set(["entries"])
GetThumbnailBatchArg._all_fields_ = [("entries", GetThumbnailBatchArg.entries.validator)]

GetThumbnailBatchError._too_many_files_validator = bv.Void()
GetThumbnailBatchError._other_validator = bv.Void()
GetThumbnailBatchError._tagmap = {
    "too_many_files": GetThumbnailBatchError._too_many_files_validator,
    "other": GetThumbnailBatchError._other_validator,
}

GetThumbnailBatchError.too_many_files = GetThumbnailBatchError("too_many_files")
GetThumbnailBatchError.other = GetThumbnailBatchError("other")

GetThumbnailBatchResult.entries.validator = bv.List(GetThumbnailBatchResultEntry_validator)
GetThumbnailBatchResult._all_field_names_ = set(["entries"])
GetThumbnailBatchResult._all_fields_ = [("entries", GetThumbnailBatchResult.entries.validator)]

GetThumbnailBatchResultData.metadata.validator = FileMetadata_validator
GetThumbnailBatchResultData.thumbnail.validator = bv.String()
GetThumbnailBatchResultData._all_field_names_ = set(
    [
        "metadata",
        "thumbnail",
    ]
)
GetThumbnailBatchResultData._all_fields_ = [
    ("metadata", GetThumbnailBatchResultData.metadata.validator),
    ("thumbnail", GetThumbnailBatchResultData.thumbnail.validator),
]

GetThumbnailBatchResultEntry._success_validator = GetThumbnailBatchResultData_validator
GetThumbnailBatchResultEntry._failure_validator = ThumbnailError_validator
GetThumbnailBatchResultEntry._other_validator = bv.Void()
GetThumbnailBatchResultEntry._tagmap = {
    "success": GetThumbnailBatchResultEntry._success_validator,
    "failure": GetThumbnailBatchResultEntry._failure_validator,
    "other": GetThumbnailBatchResultEntry._other_validator,
}

GetThumbnailBatchResultEntry.other = GetThumbnailBatchResultEntry("other")

GpsCoordinates.latitude.validator = bv.Float64()
GpsCoordinates.longitude.validator = bv.Float64()
GpsCoordinates._all_field_names_ = set(
    [
        "latitude",
        "longitude",
    ]
)
GpsCoordinates._all_fields_ = [
    ("latitude", GpsCoordinates.latitude.validator),
    ("longitude", GpsCoordinates.longitude.validator),
]

HighlightSpan.highlight_str.validator = bv.String()
HighlightSpan.is_highlighted.validator = bv.Boolean()
HighlightSpan._all_field_names_ = set(
    [
        "highlight_str",
        "is_highlighted",
    ]
)
HighlightSpan._all_fields_ = [
    ("highlight_str", HighlightSpan.highlight_str.validator),
    ("is_highlighted", HighlightSpan.is_highlighted.validator),
]

ImportFormat._html_validator = bv.Void()
ImportFormat._markdown_validator = bv.Void()
ImportFormat._plain_text_validator = bv.Void()
ImportFormat._other_validator = bv.Void()
ImportFormat._tagmap = {
    "html": ImportFormat._html_validator,
    "markdown": ImportFormat._markdown_validator,
    "plain_text": ImportFormat._plain_text_validator,
    "other": ImportFormat._other_validator,
}

ImportFormat.html = ImportFormat("html")
ImportFormat.markdown = ImportFormat("markdown")
ImportFormat.plain_text = ImportFormat("plain_text")
ImportFormat.other = ImportFormat("other")

ListFolderArg.path.validator = PathROrId_validator
ListFolderArg.recursive.validator = bv.Boolean()
ListFolderArg.include_media_info.validator = bv.Boolean()
ListFolderArg.include_deleted.validator = bv.Boolean()
ListFolderArg.include_has_explicit_shared_members.validator = bv.Boolean()
ListFolderArg.include_mounted_folders.validator = bv.Boolean()
ListFolderArg.limit.validator = bv.Nullable(bv.UInt32(min_value=1, max_value=2000))
ListFolderArg.shared_link.validator = bv.Nullable(SharedLink_validator)
ListFolderArg.include_property_groups.validator = bv.Nullable(
    file_properties.TemplateFilterBase_validator
)
ListFolderArg.include_non_downloadable_files.validator = bv.Boolean()
ListFolderArg.include_restorable_info.validator = bv.Boolean()
ListFolderArg._all_field_names_ = set(
    [
        "path",
        "recursive",
        "include_media_info",
        "include_deleted",
        "include_has_explicit_shared_members",
        "include_mounted_folders",
        "limit",
        "shared_link",
        "include_property_groups",
        "include_non_downloadable_files",
        "include_restorable_info",
    ]
)
ListFolderArg._all_fields_ = [
    ("path", ListFolderArg.path.validator),
    ("recursive", ListFolderArg.recursive.validator),
    ("include_media_info", ListFolderArg.include_media_info.validator),
    ("include_deleted", ListFolderArg.include_deleted.validator),
    (
        "include_has_explicit_shared_members",
        ListFolderArg.include_has_explicit_shared_members.validator,
    ),
    ("include_mounted_folders", ListFolderArg.include_mounted_folders.validator),
    ("limit", ListFolderArg.limit.validator),
    ("shared_link", ListFolderArg.shared_link.validator),
    ("include_property_groups", ListFolderArg.include_property_groups.validator),
    (
        "include_non_downloadable_files",
        ListFolderArg.include_non_downloadable_files.validator,
    ),
    ("include_restorable_info", ListFolderArg.include_restorable_info.validator),
]

ListFolderContinueArg.cursor.validator = ListFolderCursor_validator
ListFolderContinueArg._all_field_names_ = set(["cursor"])
ListFolderContinueArg._all_fields_ = [("cursor", ListFolderContinueArg.cursor.validator)]

ListFolderContinueError._path_validator = LookupError_validator
ListFolderContinueError._reset_validator = bv.Void()
ListFolderContinueError._other_validator = bv.Void()
ListFolderContinueError._tagmap = {
    "path": ListFolderContinueError._path_validator,
    "reset": ListFolderContinueError._reset_validator,
    "other": ListFolderContinueError._other_validator,
}

ListFolderContinueError.reset = ListFolderContinueError("reset")
ListFolderContinueError.other = ListFolderContinueError("other")

ListFolderError._path_validator = LookupError_validator
ListFolderError._template_error_validator = file_properties.TemplateError_validator
ListFolderError._other_validator = bv.Void()
ListFolderError._tagmap = {
    "path": ListFolderError._path_validator,
    "template_error": ListFolderError._template_error_validator,
    "other": ListFolderError._other_validator,
}

ListFolderError.other = ListFolderError("other")

ListFolderGetLatestCursorResult.cursor.validator = ListFolderCursor_validator
ListFolderGetLatestCursorResult._all_field_names_ = set(["cursor"])
ListFolderGetLatestCursorResult._all_fields_ = [
    ("cursor", ListFolderGetLatestCursorResult.cursor.validator)
]

ListFolderLongpollArg.cursor.validator = ListFolderCursor_validator
ListFolderLongpollArg.timeout.validator = bv.UInt64(min_value=30, max_value=480)
ListFolderLongpollArg._all_field_names_ = set(
    [
        "cursor",
        "timeout",
    ]
)
ListFolderLongpollArg._all_fields_ = [
    ("cursor", ListFolderLongpollArg.cursor.validator),
    ("timeout", ListFolderLongpollArg.timeout.validator),
]

ListFolderLongpollError._reset_validator = bv.Void()
ListFolderLongpollError._other_validator = bv.Void()
ListFolderLongpollError._tagmap = {
    "reset": ListFolderLongpollError._reset_validator,
    "other": ListFolderLongpollError._other_validator,
}

ListFolderLongpollError.reset = ListFolderLongpollError("reset")
ListFolderLongpollError.other = ListFolderLongpollError("other")

ListFolderLongpollResult.changes.validator = bv.Boolean()
ListFolderLongpollResult.backoff.validator = bv.Nullable(bv.UInt64())
ListFolderLongpollResult._all_field_names_ = set(
    [
        "changes",
        "backoff",
    ]
)
ListFolderLongpollResult._all_fields_ = [
    ("changes", ListFolderLongpollResult.changes.validator),
    ("backoff", ListFolderLongpollResult.backoff.validator),
]

ListFolderResult.entries.validator = bv.List(Metadata_validator)
ListFolderResult.cursor.validator = ListFolderCursor_validator
ListFolderResult.has_more.validator = bv.Boolean()
ListFolderResult._all_field_names_ = set(
    [
        "entries",
        "cursor",
        "has_more",
    ]
)
ListFolderResult._all_fields_ = [
    ("entries", ListFolderResult.entries.validator),
    ("cursor", ListFolderResult.cursor.validator),
    ("has_more", ListFolderResult.has_more.validator),
]

ListRevisionsArg.path.validator = PathOrId_validator
ListRevisionsArg.mode.validator = ListRevisionsMode_validator
ListRevisionsArg.limit.validator = bv.UInt64(min_value=1, max_value=100)
ListRevisionsArg.before_rev.validator = bv.Nullable(Rev_validator)
ListRevisionsArg.include_restorable_info.validator = bv.Boolean()
ListRevisionsArg._all_field_names_ = set(
    [
        "path",
        "mode",
        "limit",
        "before_rev",
        "include_restorable_info",
    ]
)
ListRevisionsArg._all_fields_ = [
    ("path", ListRevisionsArg.path.validator),
    ("mode", ListRevisionsArg.mode.validator),
    ("limit", ListRevisionsArg.limit.validator),
    ("before_rev", ListRevisionsArg.before_rev.validator),
    ("include_restorable_info", ListRevisionsArg.include_restorable_info.validator),
]

ListRevisionsError._path_validator = LookupError_validator
ListRevisionsError._invalid_before_rev_validator = bv.Void()
ListRevisionsError._before_rev_not_supported_validator = bv.Void()
ListRevisionsError._other_validator = bv.Void()
ListRevisionsError._tagmap = {
    "path": ListRevisionsError._path_validator,
    "invalid_before_rev": ListRevisionsError._invalid_before_rev_validator,
    "before_rev_not_supported": ListRevisionsError._before_rev_not_supported_validator,
    "other": ListRevisionsError._other_validator,
}

ListRevisionsError.invalid_before_rev = ListRevisionsError("invalid_before_rev")
ListRevisionsError.before_rev_not_supported = ListRevisionsError("before_rev_not_supported")
ListRevisionsError.other = ListRevisionsError("other")

ListRevisionsMode._path_validator = bv.Void()
ListRevisionsMode._id_validator = bv.Void()
ListRevisionsMode._other_validator = bv.Void()
ListRevisionsMode._tagmap = {
    "path": ListRevisionsMode._path_validator,
    "id": ListRevisionsMode._id_validator,
    "other": ListRevisionsMode._other_validator,
}

ListRevisionsMode.path = ListRevisionsMode("path")
ListRevisionsMode.id = ListRevisionsMode("id")
ListRevisionsMode.other = ListRevisionsMode("other")

ListRevisionsResult.is_deleted.validator = bv.Boolean()
ListRevisionsResult.server_deleted.validator = bv.Nullable(common.DropboxTimestamp_validator)
ListRevisionsResult.entries.validator = bv.List(FileMetadata_validator)
ListRevisionsResult.has_more.validator = bv.Boolean()
ListRevisionsResult._all_field_names_ = set(
    [
        "is_deleted",
        "server_deleted",
        "entries",
        "has_more",
    ]
)
ListRevisionsResult._all_fields_ = [
    ("is_deleted", ListRevisionsResult.is_deleted.validator),
    ("server_deleted", ListRevisionsResult.server_deleted.validator),
    ("entries", ListRevisionsResult.entries.validator),
    ("has_more", ListRevisionsResult.has_more.validator),
]

LockConflictError.lock.validator = FileLock_validator
LockConflictError._all_field_names_ = set(["lock"])
LockConflictError._all_fields_ = [("lock", LockConflictError.lock.validator)]

LockFileArg.path.validator = WritePathOrId_validator
LockFileArg._all_field_names_ = set(["path"])
LockFileArg._all_fields_ = [("path", LockFileArg.path.validator)]

LockFileBatchArg.entries.validator = bv.List(LockFileArg_validator)
LockFileBatchArg._all_field_names_ = set(["entries"])
LockFileBatchArg._all_fields_ = [("entries", LockFileBatchArg.entries.validator)]

LockFileBatchResult.entries.validator = bv.List(LockFileResultEntry_validator)
LockFileBatchResult._all_field_names_ = FileOpsResult._all_field_names_.union(set(["entries"]))
LockFileBatchResult._all_fields_ = FileOpsResult._all_fields_ + [
    ("entries", LockFileBatchResult.entries.validator)
]

LockFileError._path_lookup_validator = LookupError_validator
LockFileError._too_many_write_operations_validator = bv.Void()
LockFileError._too_many_files_validator = bv.Void()
LockFileError._no_write_permission_validator = bv.Void()
LockFileError._cannot_be_locked_validator = bv.Void()
LockFileError._file_not_shared_validator = bv.Void()
LockFileError._lock_conflict_validator = LockConflictError_validator
LockFileError._internal_error_validator = bv.Void()
LockFileError._other_validator = bv.Void()
LockFileError._tagmap = {
    "path_lookup": LockFileError._path_lookup_validator,
    "too_many_write_operations": LockFileError._too_many_write_operations_validator,
    "too_many_files": LockFileError._too_many_files_validator,
    "no_write_permission": LockFileError._no_write_permission_validator,
    "cannot_be_locked": LockFileError._cannot_be_locked_validator,
    "file_not_shared": LockFileError._file_not_shared_validator,
    "lock_conflict": LockFileError._lock_conflict_validator,
    "internal_error": LockFileError._internal_error_validator,
    "other": LockFileError._other_validator,
}

LockFileError.too_many_write_operations = LockFileError("too_many_write_operations")
LockFileError.too_many_files = LockFileError("too_many_files")
LockFileError.no_write_permission = LockFileError("no_write_permission")
LockFileError.cannot_be_locked = LockFileError("cannot_be_locked")
LockFileError.file_not_shared = LockFileError("file_not_shared")
LockFileError.internal_error = LockFileError("internal_error")
LockFileError.other = LockFileError("other")

LockFileResult.metadata.validator = Metadata_validator
LockFileResult.lock.validator = FileLock_validator
LockFileResult._all_field_names_ = set(
    [
        "metadata",
        "lock",
    ]
)
LockFileResult._all_fields_ = [
    ("metadata", LockFileResult.metadata.validator),
    ("lock", LockFileResult.lock.validator),
]

LockFileResultEntry._success_validator = LockFileResult_validator
LockFileResultEntry._failure_validator = LockFileError_validator
LockFileResultEntry._tagmap = {
    "success": LockFileResultEntry._success_validator,
    "failure": LockFileResultEntry._failure_validator,
}

LookupError._malformed_path_validator = MalformedPathError_validator
LookupError._not_found_validator = bv.Void()
LookupError._not_file_validator = bv.Void()
LookupError._not_folder_validator = bv.Void()
LookupError._restricted_content_validator = bv.Void()
LookupError._unsupported_content_type_validator = bv.Void()
LookupError._locked_validator = bv.Void()
LookupError._other_validator = bv.Void()
LookupError._tagmap = {
    "malformed_path": LookupError._malformed_path_validator,
    "not_found": LookupError._not_found_validator,
    "not_file": LookupError._not_file_validator,
    "not_folder": LookupError._not_folder_validator,
    "restricted_content": LookupError._restricted_content_validator,
    "unsupported_content_type": LookupError._unsupported_content_type_validator,
    "locked": LookupError._locked_validator,
    "other": LookupError._other_validator,
}

LookupError.not_found = LookupError("not_found")
LookupError.not_file = LookupError("not_file")
LookupError.not_folder = LookupError("not_folder")
LookupError.restricted_content = LookupError("restricted_content")
LookupError.unsupported_content_type = LookupError("unsupported_content_type")
LookupError.locked = LookupError("locked")
LookupError.other = LookupError("other")

MediaInfo._pending_validator = bv.Void()
MediaInfo._metadata_validator = MediaMetadata_validator
MediaInfo._tagmap = {
    "pending": MediaInfo._pending_validator,
    "metadata": MediaInfo._metadata_validator,
}

MediaInfo.pending = MediaInfo("pending")

MediaMetadata.dimensions.validator = bv.Nullable(Dimensions_validator)
MediaMetadata.location.validator = bv.Nullable(GpsCoordinates_validator)
MediaMetadata.time_taken.validator = bv.Nullable(common.DropboxTimestamp_validator)
MediaMetadata._field_names_ = set(
    [
        "dimensions",
        "location",
        "time_taken",
    ]
)
MediaMetadata._all_field_names_ = MediaMetadata._field_names_
MediaMetadata._fields_ = [
    ("dimensions", MediaMetadata.dimensions.validator),
    ("location", MediaMetadata.location.validator),
    ("time_taken", MediaMetadata.time_taken.validator),
]
MediaMetadata._all_fields_ = MediaMetadata._fields_

MediaMetadata._tag_to_subtype_ = {
    ("photo",): PhotoMetadata_validator,
    ("video",): VideoMetadata_validator,
}
MediaMetadata._pytype_to_tag_and_subtype_ = {
    PhotoMetadata: (("photo",), PhotoMetadata_validator),
    VideoMetadata: (("video",), VideoMetadata_validator),
}
MediaMetadata._is_catch_all_ = False

MetadataV2._metadata_validator = Metadata_validator
MetadataV2._other_validator = bv.Void()
MetadataV2._tagmap = {
    "metadata": MetadataV2._metadata_validator,
    "other": MetadataV2._other_validator,
}

MetadataV2.other = MetadataV2("other")

MinimalFileLinkMetadata.url.validator = bv.String()
MinimalFileLinkMetadata.id.validator = bv.Nullable(Id_validator)
MinimalFileLinkMetadata.path.validator = bv.Nullable(bv.String())
MinimalFileLinkMetadata.rev.validator = Rev_validator
MinimalFileLinkMetadata._all_field_names_ = set(
    [
        "url",
        "id",
        "path",
        "rev",
    ]
)
MinimalFileLinkMetadata._all_fields_ = [
    ("url", MinimalFileLinkMetadata.url.validator),
    ("id", MinimalFileLinkMetadata.id.validator),
    ("path", MinimalFileLinkMetadata.path.validator),
    ("rev", MinimalFileLinkMetadata.rev.validator),
]

RelocationBatchArgBase.entries.validator = bv.List(
    RelocationPath_validator, min_items=1, max_items=1000
)
RelocationBatchArgBase.autorename.validator = bv.Boolean()
RelocationBatchArgBase._all_field_names_ = set(
    [
        "entries",
        "autorename",
    ]
)
RelocationBatchArgBase._all_fields_ = [
    ("entries", RelocationBatchArgBase.entries.validator),
    ("autorename", RelocationBatchArgBase.autorename.validator),
]

MoveBatchArg.allow_ownership_transfer.validator = bv.Boolean()
MoveBatchArg._all_field_names_ = RelocationBatchArgBase._all_field_names_.union(
    set(["allow_ownership_transfer"])
)
MoveBatchArg._all_fields_ = RelocationBatchArgBase._all_fields_ + [
    ("allow_ownership_transfer", MoveBatchArg.allow_ownership_transfer.validator)
]

MoveIntoFamilyError._is_shared_folder_validator = bv.Void()
MoveIntoFamilyError._other_validator = bv.Void()
MoveIntoFamilyError._tagmap = {
    "is_shared_folder": MoveIntoFamilyError._is_shared_folder_validator,
    "other": MoveIntoFamilyError._other_validator,
}

MoveIntoFamilyError.is_shared_folder = MoveIntoFamilyError("is_shared_folder")
MoveIntoFamilyError.other = MoveIntoFamilyError("other")

MoveIntoVaultError._is_shared_folder_validator = bv.Void()
MoveIntoVaultError._other_validator = bv.Void()
MoveIntoVaultError._tagmap = {
    "is_shared_folder": MoveIntoVaultError._is_shared_folder_validator,
    "other": MoveIntoVaultError._other_validator,
}

MoveIntoVaultError.is_shared_folder = MoveIntoVaultError("is_shared_folder")
MoveIntoVaultError.other = MoveIntoVaultError("other")

PaperContentError._insufficient_permissions_validator = bv.Void()
PaperContentError._content_malformed_validator = bv.Void()
PaperContentError._doc_length_exceeded_validator = bv.Void()
PaperContentError._image_size_exceeded_validator = bv.Void()
PaperContentError._other_validator = bv.Void()
PaperContentError._tagmap = {
    "insufficient_permissions": PaperContentError._insufficient_permissions_validator,
    "content_malformed": PaperContentError._content_malformed_validator,
    "doc_length_exceeded": PaperContentError._doc_length_exceeded_validator,
    "image_size_exceeded": PaperContentError._image_size_exceeded_validator,
    "other": PaperContentError._other_validator,
}

PaperContentError.insufficient_permissions = PaperContentError("insufficient_permissions")
PaperContentError.content_malformed = PaperContentError("content_malformed")
PaperContentError.doc_length_exceeded = PaperContentError("doc_length_exceeded")
PaperContentError.image_size_exceeded = PaperContentError("image_size_exceeded")
PaperContentError.other = PaperContentError("other")

PaperCreateArg.path.validator = Path_validator
PaperCreateArg.import_format.validator = ImportFormat_validator
PaperCreateArg._all_field_names_ = set(
    [
        "path",
        "import_format",
    ]
)
PaperCreateArg._all_fields_ = [
    ("path", PaperCreateArg.path.validator),
    ("import_format", PaperCreateArg.import_format.validator),
]

PaperCreateError._invalid_path_validator = bv.Void()
PaperCreateError._email_unverified_validator = bv.Void()
PaperCreateError._invalid_file_extension_validator = bv.Void()
PaperCreateError._paper_disabled_validator = bv.Void()
PaperCreateError._tagmap = {
    "invalid_path": PaperCreateError._invalid_path_validator,
    "email_unverified": PaperCreateError._email_unverified_validator,
    "invalid_file_extension": PaperCreateError._invalid_file_extension_validator,
    "paper_disabled": PaperCreateError._paper_disabled_validator,
}
PaperCreateError._tagmap.update(PaperContentError._tagmap)

PaperCreateError.invalid_path = PaperCreateError("invalid_path")
PaperCreateError.email_unverified = PaperCreateError("email_unverified")
PaperCreateError.invalid_file_extension = PaperCreateError("invalid_file_extension")
PaperCreateError.paper_disabled = PaperCreateError("paper_disabled")

PaperCreateResult.url.validator = bv.String()
PaperCreateResult.result_path.validator = bv.String()
PaperCreateResult.file_id.validator = FileId_validator
PaperCreateResult.paper_revision.validator = bv.Int64()
PaperCreateResult._all_field_names_ = set(
    [
        "url",
        "result_path",
        "file_id",
        "paper_revision",
    ]
)
PaperCreateResult._all_fields_ = [
    ("url", PaperCreateResult.url.validator),
    ("result_path", PaperCreateResult.result_path.validator),
    ("file_id", PaperCreateResult.file_id.validator),
    ("paper_revision", PaperCreateResult.paper_revision.validator),
]

PaperDocUpdatePolicy._update_validator = bv.Void()
PaperDocUpdatePolicy._overwrite_validator = bv.Void()
PaperDocUpdatePolicy._prepend_validator = bv.Void()
PaperDocUpdatePolicy._append_validator = bv.Void()
PaperDocUpdatePolicy._other_validator = bv.Void()
PaperDocUpdatePolicy._tagmap = {
    "update": PaperDocUpdatePolicy._update_validator,
    "overwrite": PaperDocUpdatePolicy._overwrite_validator,
    "prepend": PaperDocUpdatePolicy._prepend_validator,
    "append": PaperDocUpdatePolicy._append_validator,
    "other": PaperDocUpdatePolicy._other_validator,
}

PaperDocUpdatePolicy.update = PaperDocUpdatePolicy("update")
PaperDocUpdatePolicy.overwrite = PaperDocUpdatePolicy("overwrite")
PaperDocUpdatePolicy.prepend = PaperDocUpdatePolicy("prepend")
PaperDocUpdatePolicy.append = PaperDocUpdatePolicy("append")
PaperDocUpdatePolicy.other = PaperDocUpdatePolicy("other")

PaperUpdateArg.path.validator = WritePathOrId_validator
PaperUpdateArg.import_format.validator = ImportFormat_validator
PaperUpdateArg.doc_update_policy.validator = PaperDocUpdatePolicy_validator
PaperUpdateArg.paper_revision.validator = bv.Nullable(bv.Int64())
PaperUpdateArg._all_field_names_ = set(
    [
        "path",
        "import_format",
        "doc_update_policy",
        "paper_revision",
    ]
)
PaperUpdateArg._all_fields_ = [
    ("path", PaperUpdateArg.path.validator),
    ("import_format", PaperUpdateArg.import_format.validator),
    ("doc_update_policy", PaperUpdateArg.doc_update_policy.validator),
    ("paper_revision", PaperUpdateArg.paper_revision.validator),
]

PaperUpdateError._path_validator = LookupError_validator
PaperUpdateError._revision_mismatch_validator = bv.Void()
PaperUpdateError._doc_archived_validator = bv.Void()
PaperUpdateError._doc_deleted_validator = bv.Void()
PaperUpdateError._tagmap = {
    "path": PaperUpdateError._path_validator,
    "revision_mismatch": PaperUpdateError._revision_mismatch_validator,
    "doc_archived": PaperUpdateError._doc_archived_validator,
    "doc_deleted": PaperUpdateError._doc_deleted_validator,
}
PaperUpdateError._tagmap.update(PaperContentError._tagmap)

PaperUpdateError.revision_mismatch = PaperUpdateError("revision_mismatch")
PaperUpdateError.doc_archived = PaperUpdateError("doc_archived")
PaperUpdateError.doc_deleted = PaperUpdateError("doc_deleted")

PaperUpdateResult.paper_revision.validator = bv.Int64()
PaperUpdateResult._all_field_names_ = set(["paper_revision"])
PaperUpdateResult._all_fields_ = [("paper_revision", PaperUpdateResult.paper_revision.validator)]

PathOrLink._path_validator = ReadPath_validator
PathOrLink._link_validator = SharedLinkFileInfo_validator
PathOrLink._other_validator = bv.Void()
PathOrLink._tagmap = {
    "path": PathOrLink._path_validator,
    "link": PathOrLink._link_validator,
    "other": PathOrLink._other_validator,
}

PathOrLink.other = PathOrLink("other")

PathToTags.path.validator = Path_validator
PathToTags.tags.validator = bv.List(Tag_validator)
PathToTags._all_field_names_ = set(
    [
        "path",
        "tags",
    ]
)
PathToTags._all_fields_ = [
    ("path", PathToTags.path.validator),
    ("tags", PathToTags.tags.validator),
]

PhotoMetadata._field_names_ = set([])
PhotoMetadata._all_field_names_ = MediaMetadata._all_field_names_.union(PhotoMetadata._field_names_)
PhotoMetadata._fields_ = []
PhotoMetadata._all_fields_ = MediaMetadata._all_fields_ + PhotoMetadata._fields_

PreviewArg.path.validator = ReadPath_validator
PreviewArg.rev.validator = bv.Nullable(Rev_validator)
PreviewArg._all_field_names_ = set(
    [
        "path",
        "rev",
    ]
)
PreviewArg._all_fields_ = [
    ("path", PreviewArg.path.validator),
    ("rev", PreviewArg.rev.validator),
]

PreviewError._path_validator = LookupError_validator
PreviewError._in_progress_validator = bv.Void()
PreviewError._unsupported_extension_validator = bv.Void()
PreviewError._unsupported_content_validator = bv.Void()
PreviewError._tagmap = {
    "path": PreviewError._path_validator,
    "in_progress": PreviewError._in_progress_validator,
    "unsupported_extension": PreviewError._unsupported_extension_validator,
    "unsupported_content": PreviewError._unsupported_content_validator,
}

PreviewError.in_progress = PreviewError("in_progress")
PreviewError.unsupported_extension = PreviewError("unsupported_extension")
PreviewError.unsupported_content = PreviewError("unsupported_content")

PreviewResult.file_metadata.validator = bv.Nullable(FileMetadata_validator)
PreviewResult.link_metadata.validator = bv.Nullable(MinimalFileLinkMetadata_validator)
PreviewResult._all_field_names_ = set(
    [
        "file_metadata",
        "link_metadata",
    ]
)
PreviewResult._all_fields_ = [
    ("file_metadata", PreviewResult.file_metadata.validator),
    ("link_metadata", PreviewResult.link_metadata.validator),
]

RelocationPath.from_path.validator = WritePathOrId_validator
RelocationPath.to_path.validator = WritePathOrId_validator
RelocationPath._all_field_names_ = set(
    [
        "from_path",
        "to_path",
    ]
)
RelocationPath._all_fields_ = [
    ("from_path", RelocationPath.from_path.validator),
    ("to_path", RelocationPath.to_path.validator),
]

RelocationArg.allow_shared_folder.validator = bv.Boolean()
RelocationArg.autorename.validator = bv.Boolean()
RelocationArg.allow_ownership_transfer.validator = bv.Boolean()
RelocationArg._all_field_names_ = RelocationPath._all_field_names_.union(
    set(
        [
            "allow_shared_folder",
            "autorename",
            "allow_ownership_transfer",
        ]
    )
)
RelocationArg._all_fields_ = RelocationPath._all_fields_ + [
    ("allow_shared_folder", RelocationArg.allow_shared_folder.validator),
    ("autorename", RelocationArg.autorename.validator),
    ("allow_ownership_transfer", RelocationArg.allow_ownership_transfer.validator),
]

RelocationBatchArg.allow_shared_folder.validator = bv.Boolean()
RelocationBatchArg.allow_ownership_transfer.validator = bv.Boolean()
RelocationBatchArg._all_field_names_ = RelocationBatchArgBase._all_field_names_.union(
    set(
        [
            "allow_shared_folder",
            "allow_ownership_transfer",
        ]
    )
)
RelocationBatchArg._all_fields_ = RelocationBatchArgBase._all_fields_ + [
    ("allow_shared_folder", RelocationBatchArg.allow_shared_folder.validator),
    ("allow_ownership_transfer", RelocationBatchArg.allow_ownership_transfer.validator),
]

RelocationError._from_lookup_validator = LookupError_validator
RelocationError._from_write_validator = WriteError_validator
RelocationError._to_validator = WriteError_validator
RelocationError._cant_copy_shared_folder_validator = bv.Void()
RelocationError._cant_nest_shared_folder_validator = bv.Void()
RelocationError._cant_move_folder_into_itself_validator = bv.Void()
RelocationError._too_many_files_validator = bv.Void()
RelocationError._duplicated_or_nested_paths_validator = bv.Void()
RelocationError._cant_transfer_ownership_validator = bv.Void()
RelocationError._insufficient_quota_validator = bv.Void()
RelocationError._internal_error_validator = bv.Void()
RelocationError._cant_move_shared_folder_validator = bv.Void()
RelocationError._cant_move_into_vault_validator = MoveIntoVaultError_validator
RelocationError._cant_move_into_family_validator = MoveIntoFamilyError_validator
RelocationError._other_validator = bv.Void()
RelocationError._tagmap = {
    "from_lookup": RelocationError._from_lookup_validator,
    "from_write": RelocationError._from_write_validator,
    "to": RelocationError._to_validator,
    "cant_copy_shared_folder": RelocationError._cant_copy_shared_folder_validator,
    "cant_nest_shared_folder": RelocationError._cant_nest_shared_folder_validator,
    "cant_move_folder_into_itself": RelocationError._cant_move_folder_into_itself_validator,
    "too_many_files": RelocationError._too_many_files_validator,
    "duplicated_or_nested_paths": RelocationError._duplicated_or_nested_paths_validator,
    "cant_transfer_ownership": RelocationError._cant_transfer_ownership_validator,
    "insufficient_quota": RelocationError._insufficient_quota_validator,
    "internal_error": RelocationError._internal_error_validator,
    "cant_move_shared_folder": RelocationError._cant_move_shared_folder_validator,
    "cant_move_into_vault": RelocationError._cant_move_into_vault_validator,
    "cant_move_into_family": RelocationError._cant_move_into_family_validator,
    "other": RelocationError._other_validator,
}

RelocationError.cant_copy_shared_folder = RelocationError("cant_copy_shared_folder")
RelocationError.cant_nest_shared_folder = RelocationError("cant_nest_shared_folder")
RelocationError.cant_move_folder_into_itself = RelocationError("cant_move_folder_into_itself")
RelocationError.too_many_files = RelocationError("too_many_files")
RelocationError.duplicated_or_nested_paths = RelocationError("duplicated_or_nested_paths")
RelocationError.cant_transfer_ownership = RelocationError("cant_transfer_ownership")
RelocationError.insufficient_quota = RelocationError("insufficient_quota")
RelocationError.internal_error = RelocationError("internal_error")
RelocationError.cant_move_shared_folder = RelocationError("cant_move_shared_folder")
RelocationError.other = RelocationError("other")

RelocationBatchError._too_many_write_operations_validator = bv.Void()
RelocationBatchError._tagmap = {
    "too_many_write_operations": RelocationBatchError._too_many_write_operations_validator,
}
RelocationBatchError._tagmap.update(RelocationError._tagmap)

RelocationBatchError.too_many_write_operations = RelocationBatchError("too_many_write_operations")

RelocationBatchErrorEntry._relocation_error_validator = RelocationError_validator
RelocationBatchErrorEntry._internal_error_validator = bv.Void()
RelocationBatchErrorEntry._too_many_write_operations_validator = bv.Void()
RelocationBatchErrorEntry._other_validator = bv.Void()
RelocationBatchErrorEntry._tagmap = {
    "relocation_error": RelocationBatchErrorEntry._relocation_error_validator,
    "internal_error": RelocationBatchErrorEntry._internal_error_validator,
    "too_many_write_operations": RelocationBatchErrorEntry._too_many_write_operations_validator,
    "other": RelocationBatchErrorEntry._other_validator,
}

RelocationBatchErrorEntry.internal_error = RelocationBatchErrorEntry("internal_error")
RelocationBatchErrorEntry.too_many_write_operations = RelocationBatchErrorEntry(
    "too_many_write_operations"
)
RelocationBatchErrorEntry.other = RelocationBatchErrorEntry("other")

RelocationBatchJobStatus._complete_validator = RelocationBatchResult_validator
RelocationBatchJobStatus._failed_validator = RelocationBatchError_validator
RelocationBatchJobStatus._tagmap = {
    "complete": RelocationBatchJobStatus._complete_validator,
    "failed": RelocationBatchJobStatus._failed_validator,
}
RelocationBatchJobStatus._tagmap.update(async_.PollResultBase._tagmap)

RelocationBatchLaunch._complete_validator = RelocationBatchResult_validator
RelocationBatchLaunch._other_validator = bv.Void()
RelocationBatchLaunch._tagmap = {
    "complete": RelocationBatchLaunch._complete_validator,
    "other": RelocationBatchLaunch._other_validator,
}
RelocationBatchLaunch._tagmap.update(async_.LaunchResultBase._tagmap)

RelocationBatchLaunch.other = RelocationBatchLaunch("other")

RelocationBatchResult.entries.validator = bv.List(RelocationBatchResultData_validator)
RelocationBatchResult._all_field_names_ = FileOpsResult._all_field_names_.union(set(["entries"]))
RelocationBatchResult._all_fields_ = FileOpsResult._all_fields_ + [
    ("entries", RelocationBatchResult.entries.validator)
]

RelocationBatchResultData.metadata.validator = Metadata_validator
RelocationBatchResultData._all_field_names_ = set(["metadata"])
RelocationBatchResultData._all_fields_ = [
    ("metadata", RelocationBatchResultData.metadata.validator)
]

RelocationBatchResultEntry._success_validator = Metadata_validator
RelocationBatchResultEntry._failure_validator = RelocationBatchErrorEntry_validator
RelocationBatchResultEntry._other_validator = bv.Void()
RelocationBatchResultEntry._tagmap = {
    "success": RelocationBatchResultEntry._success_validator,
    "failure": RelocationBatchResultEntry._failure_validator,
    "other": RelocationBatchResultEntry._other_validator,
}

RelocationBatchResultEntry.other = RelocationBatchResultEntry("other")

RelocationBatchV2JobStatus._complete_validator = RelocationBatchV2Result_validator
RelocationBatchV2JobStatus._tagmap = {
    "complete": RelocationBatchV2JobStatus._complete_validator,
}
RelocationBatchV2JobStatus._tagmap.update(async_.PollResultBase._tagmap)

RelocationBatchV2Launch._complete_validator = RelocationBatchV2Result_validator
RelocationBatchV2Launch._tagmap = {
    "complete": RelocationBatchV2Launch._complete_validator,
}
RelocationBatchV2Launch._tagmap.update(async_.LaunchResultBase._tagmap)

RelocationBatchV2Result.entries.validator = bv.List(RelocationBatchResultEntry_validator)
RelocationBatchV2Result._all_field_names_ = FileOpsResult._all_field_names_.union(set(["entries"]))
RelocationBatchV2Result._all_fields_ = FileOpsResult._all_fields_ + [
    ("entries", RelocationBatchV2Result.entries.validator)
]

RelocationResult.metadata.validator = Metadata_validator
RelocationResult._all_field_names_ = FileOpsResult._all_field_names_.union(set(["metadata"]))
RelocationResult._all_fields_ = FileOpsResult._all_fields_ + [
    ("metadata", RelocationResult.metadata.validator)
]

RemoveTagArg.path.validator = Path_validator
RemoveTagArg.tag_text.validator = TagText_validator
RemoveTagArg._all_field_names_ = set(
    [
        "path",
        "tag_text",
    ]
)
RemoveTagArg._all_fields_ = [
    ("path", RemoveTagArg.path.validator),
    ("tag_text", RemoveTagArg.tag_text.validator),
]

RemoveTagError._tag_not_present_validator = bv.Void()
RemoveTagError._tagmap = {
    "tag_not_present": RemoveTagError._tag_not_present_validator,
}
RemoveTagError._tagmap.update(BaseTagError._tagmap)

RemoveTagError.tag_not_present = RemoveTagError("tag_not_present")

RestoreArg.path.validator = WritePath_validator
RestoreArg.rev.validator = Rev_validator
RestoreArg._all_field_names_ = set(
    [
        "path",
        "rev",
    ]
)
RestoreArg._all_fields_ = [
    ("path", RestoreArg.path.validator),
    ("rev", RestoreArg.rev.validator),
]

RestoreError._path_lookup_validator = LookupError_validator
RestoreError._path_write_validator = WriteError_validator
RestoreError._invalid_revision_validator = bv.Void()
RestoreError._in_progress_validator = bv.Void()
RestoreError._other_validator = bv.Void()
RestoreError._tagmap = {
    "path_lookup": RestoreError._path_lookup_validator,
    "path_write": RestoreError._path_write_validator,
    "invalid_revision": RestoreError._invalid_revision_validator,
    "in_progress": RestoreError._in_progress_validator,
    "other": RestoreError._other_validator,
}

RestoreError.invalid_revision = RestoreError("invalid_revision")
RestoreError.in_progress = RestoreError("in_progress")
RestoreError.other = RestoreError("other")

SaveCopyReferenceArg.copy_reference.validator = bv.String()
SaveCopyReferenceArg.path.validator = Path_validator
SaveCopyReferenceArg._all_field_names_ = set(
    [
        "copy_reference",
        "path",
    ]
)
SaveCopyReferenceArg._all_fields_ = [
    ("copy_reference", SaveCopyReferenceArg.copy_reference.validator),
    ("path", SaveCopyReferenceArg.path.validator),
]

SaveCopyReferenceError._path_validator = WriteError_validator
SaveCopyReferenceError._invalid_copy_reference_validator = bv.Void()
SaveCopyReferenceError._no_permission_validator = bv.Void()
SaveCopyReferenceError._not_found_validator = bv.Void()
SaveCopyReferenceError._too_many_files_validator = bv.Void()
SaveCopyReferenceError._other_validator = bv.Void()
SaveCopyReferenceError._tagmap = {
    "path": SaveCopyReferenceError._path_validator,
    "invalid_copy_reference": SaveCopyReferenceError._invalid_copy_reference_validator,
    "no_permission": SaveCopyReferenceError._no_permission_validator,
    "not_found": SaveCopyReferenceError._not_found_validator,
    "too_many_files": SaveCopyReferenceError._too_many_files_validator,
    "other": SaveCopyReferenceError._other_validator,
}

SaveCopyReferenceError.invalid_copy_reference = SaveCopyReferenceError("invalid_copy_reference")
SaveCopyReferenceError.no_permission = SaveCopyReferenceError("no_permission")
SaveCopyReferenceError.not_found = SaveCopyReferenceError("not_found")
SaveCopyReferenceError.too_many_files = SaveCopyReferenceError("too_many_files")
SaveCopyReferenceError.other = SaveCopyReferenceError("other")

SaveCopyReferenceResult.metadata.validator = Metadata_validator
SaveCopyReferenceResult._all_field_names_ = set(["metadata"])
SaveCopyReferenceResult._all_fields_ = [("metadata", SaveCopyReferenceResult.metadata.validator)]

SaveUrlArg.path.validator = Path_validator
SaveUrlArg.url.validator = bv.String()
SaveUrlArg._all_field_names_ = set(
    [
        "path",
        "url",
    ]
)
SaveUrlArg._all_fields_ = [
    ("path", SaveUrlArg.path.validator),
    ("url", SaveUrlArg.url.validator),
]

SaveUrlError._path_validator = WriteError_validator
SaveUrlError._download_failed_validator = bv.Void()
SaveUrlError._invalid_url_validator = bv.Void()
SaveUrlError._not_found_validator = bv.Void()
SaveUrlError._other_validator = bv.Void()
SaveUrlError._tagmap = {
    "path": SaveUrlError._path_validator,
    "download_failed": SaveUrlError._download_failed_validator,
    "invalid_url": SaveUrlError._invalid_url_validator,
    "not_found": SaveUrlError._not_found_validator,
    "other": SaveUrlError._other_validator,
}

SaveUrlError.download_failed = SaveUrlError("download_failed")
SaveUrlError.invalid_url = SaveUrlError("invalid_url")
SaveUrlError.not_found = SaveUrlError("not_found")
SaveUrlError.other = SaveUrlError("other")

SaveUrlJobStatus._complete_validator = FileMetadata_validator
SaveUrlJobStatus._failed_validator = SaveUrlError_validator
SaveUrlJobStatus._tagmap = {
    "complete": SaveUrlJobStatus._complete_validator,
    "failed": SaveUrlJobStatus._failed_validator,
}
SaveUrlJobStatus._tagmap.update(async_.PollResultBase._tagmap)

SaveUrlResult._complete_validator = FileMetadata_validator
SaveUrlResult._tagmap = {
    "complete": SaveUrlResult._complete_validator,
}
SaveUrlResult._tagmap.update(async_.LaunchResultBase._tagmap)

SearchArg.path.validator = PathROrId_validator
SearchArg.query.validator = bv.String(max_length=1000)
SearchArg.start.validator = bv.UInt64(max_value=9999)
SearchArg.max_results.validator = bv.UInt64(min_value=1, max_value=1000)
SearchArg.mode.validator = SearchMode_validator
SearchArg._all_field_names_ = set(
    [
        "path",
        "query",
        "start",
        "max_results",
        "mode",
    ]
)
SearchArg._all_fields_ = [
    ("path", SearchArg.path.validator),
    ("query", SearchArg.query.validator),
    ("start", SearchArg.start.validator),
    ("max_results", SearchArg.max_results.validator),
    ("mode", SearchArg.mode.validator),
]

SearchError._path_validator = LookupError_validator
SearchError._invalid_argument_validator = bv.Nullable(bv.String())
SearchError._internal_error_validator = bv.Void()
SearchError._other_validator = bv.Void()
SearchError._tagmap = {
    "path": SearchError._path_validator,
    "invalid_argument": SearchError._invalid_argument_validator,
    "internal_error": SearchError._internal_error_validator,
    "other": SearchError._other_validator,
}

SearchError.internal_error = SearchError("internal_error")
SearchError.other = SearchError("other")

SearchMatch.match_type.validator = SearchMatchType_validator
SearchMatch.metadata.validator = Metadata_validator
SearchMatch._all_field_names_ = set(
    [
        "match_type",
        "metadata",
    ]
)
SearchMatch._all_fields_ = [
    ("match_type", SearchMatch.match_type.validator),
    ("metadata", SearchMatch.metadata.validator),
]

SearchMatchFieldOptions.include_highlights.validator = bv.Boolean()
SearchMatchFieldOptions._all_field_names_ = set(["include_highlights"])
SearchMatchFieldOptions._all_fields_ = [
    ("include_highlights", SearchMatchFieldOptions.include_highlights.validator)
]

SearchMatchType._filename_validator = bv.Void()
SearchMatchType._content_validator = bv.Void()
SearchMatchType._both_validator = bv.Void()
SearchMatchType._tagmap = {
    "filename": SearchMatchType._filename_validator,
    "content": SearchMatchType._content_validator,
    "both": SearchMatchType._both_validator,
}

SearchMatchType.filename = SearchMatchType("filename")
SearchMatchType.content = SearchMatchType("content")
SearchMatchType.both = SearchMatchType("both")

SearchMatchTypeV2._filename_validator = bv.Void()
SearchMatchTypeV2._file_content_validator = bv.Void()
SearchMatchTypeV2._filename_and_content_validator = bv.Void()
SearchMatchTypeV2._image_content_validator = bv.Void()
SearchMatchTypeV2._metadata_validator = bv.Void()
SearchMatchTypeV2._other_validator = bv.Void()
SearchMatchTypeV2._tagmap = {
    "filename": SearchMatchTypeV2._filename_validator,
    "file_content": SearchMatchTypeV2._file_content_validator,
    "filename_and_content": SearchMatchTypeV2._filename_and_content_validator,
    "image_content": SearchMatchTypeV2._image_content_validator,
    "metadata": SearchMatchTypeV2._metadata_validator,
    "other": SearchMatchTypeV2._other_validator,
}

SearchMatchTypeV2.filename = SearchMatchTypeV2("filename")
SearchMatchTypeV2.file_content = SearchMatchTypeV2("file_content")
SearchMatchTypeV2.filename_and_content = SearchMatchTypeV2("filename_and_content")
SearchMatchTypeV2.image_content = SearchMatchTypeV2("image_content")
SearchMatchTypeV2.metadata = SearchMatchTypeV2("metadata")
SearchMatchTypeV2.other = SearchMatchTypeV2("other")

SearchMatchV2.metadata.validator = MetadataV2_validator
SearchMatchV2.match_type.validator = bv.Nullable(SearchMatchTypeV2_validator)
SearchMatchV2.highlight_spans.validator = bv.Nullable(bv.List(HighlightSpan_validator))
SearchMatchV2._all_field_names_ = set(
    [
        "metadata",
        "match_type",
        "highlight_spans",
    ]
)
SearchMatchV2._all_fields_ = [
    ("metadata", SearchMatchV2.metadata.validator),
    ("match_type", SearchMatchV2.match_type.validator),
    ("highlight_spans", SearchMatchV2.highlight_spans.validator),
]

SearchMode._filename_validator = bv.Void()
SearchMode._filename_and_content_validator = bv.Void()
SearchMode._deleted_filename_validator = bv.Void()
SearchMode._tagmap = {
    "filename": SearchMode._filename_validator,
    "filename_and_content": SearchMode._filename_and_content_validator,
    "deleted_filename": SearchMode._deleted_filename_validator,
}

SearchMode.filename = SearchMode("filename")
SearchMode.filename_and_content = SearchMode("filename_and_content")
SearchMode.deleted_filename = SearchMode("deleted_filename")

SearchOptions.path.validator = bv.Nullable(PathROrId_validator)
SearchOptions.max_results.validator = bv.UInt64(min_value=1, max_value=1000)
SearchOptions.order_by.validator = bv.Nullable(SearchOrderBy_validator)
SearchOptions.file_status.validator = FileStatus_validator
SearchOptions.filename_only.validator = bv.Boolean()
SearchOptions.file_extensions.validator = bv.Nullable(bv.List(bv.String()))
SearchOptions.file_categories.validator = bv.Nullable(bv.List(FileCategory_validator))
SearchOptions.account_id.validator = bv.Nullable(users_common.AccountId_validator)
SearchOptions._all_field_names_ = set(
    [
        "path",
        "max_results",
        "order_by",
        "file_status",
        "filename_only",
        "file_extensions",
        "file_categories",
        "account_id",
    ]
)
SearchOptions._all_fields_ = [
    ("path", SearchOptions.path.validator),
    ("max_results", SearchOptions.max_results.validator),
    ("order_by", SearchOptions.order_by.validator),
    ("file_status", SearchOptions.file_status.validator),
    ("filename_only", SearchOptions.filename_only.validator),
    ("file_extensions", SearchOptions.file_extensions.validator),
    ("file_categories", SearchOptions.file_categories.validator),
    ("account_id", SearchOptions.account_id.validator),
]

SearchOrderBy._relevance_validator = bv.Void()
SearchOrderBy._last_modified_time_validator = bv.Void()
SearchOrderBy._other_validator = bv.Void()
SearchOrderBy._tagmap = {
    "relevance": SearchOrderBy._relevance_validator,
    "last_modified_time": SearchOrderBy._last_modified_time_validator,
    "other": SearchOrderBy._other_validator,
}

SearchOrderBy.relevance = SearchOrderBy("relevance")
SearchOrderBy.last_modified_time = SearchOrderBy("last_modified_time")
SearchOrderBy.other = SearchOrderBy("other")

SearchResult.matches.validator = bv.List(SearchMatch_validator)
SearchResult.more.validator = bv.Boolean()
SearchResult.start.validator = bv.UInt64()
SearchResult._all_field_names_ = set(
    [
        "matches",
        "more",
        "start",
    ]
)
SearchResult._all_fields_ = [
    ("matches", SearchResult.matches.validator),
    ("more", SearchResult.more.validator),
    ("start", SearchResult.start.validator),
]

SearchV2Arg.query.validator = bv.String(max_length=1000)
SearchV2Arg.options.validator = bv.Nullable(SearchOptions_validator)
SearchV2Arg.match_field_options.validator = bv.Nullable(SearchMatchFieldOptions_validator)
SearchV2Arg.include_highlights.validator = bv.Nullable(bv.Boolean())
SearchV2Arg._all_field_names_ = set(
    [
        "query",
        "options",
        "match_field_options",
        "include_highlights",
    ]
)
SearchV2Arg._all_fields_ = [
    ("query", SearchV2Arg.query.validator),
    ("options", SearchV2Arg.options.validator),
    ("match_field_options", SearchV2Arg.match_field_options.validator),
    ("include_highlights", SearchV2Arg.include_highlights.validator),
]

SearchV2ContinueArg.cursor.validator = SearchV2Cursor_validator
SearchV2ContinueArg._all_field_names_ = set(["cursor"])
SearchV2ContinueArg._all_fields_ = [("cursor", SearchV2ContinueArg.cursor.validator)]

SearchV2Result.matches.validator = bv.List(SearchMatchV2_validator)
SearchV2Result.has_more.validator = bv.Boolean()
SearchV2Result.cursor.validator = bv.Nullable(SearchV2Cursor_validator)
SearchV2Result._all_field_names_ = set(
    [
        "matches",
        "has_more",
        "cursor",
    ]
)
SearchV2Result._all_fields_ = [
    ("matches", SearchV2Result.matches.validator),
    ("has_more", SearchV2Result.has_more.validator),
    ("cursor", SearchV2Result.cursor.validator),
]

SharedLink.url.validator = SharedLinkUrl_validator
SharedLink.password.validator = bv.Nullable(bv.String())
SharedLink._all_field_names_ = set(
    [
        "url",
        "password",
    ]
)
SharedLink._all_fields_ = [
    ("url", SharedLink.url.validator),
    ("password", SharedLink.password.validator),
]

SharedLinkFileInfo.url.validator = bv.String()
SharedLinkFileInfo.path.validator = bv.Nullable(bv.String())
SharedLinkFileInfo.password.validator = bv.Nullable(bv.String())
SharedLinkFileInfo._all_field_names_ = set(
    [
        "url",
        "path",
        "password",
    ]
)
SharedLinkFileInfo._all_fields_ = [
    ("url", SharedLinkFileInfo.url.validator),
    ("path", SharedLinkFileInfo.path.validator),
    ("password", SharedLinkFileInfo.password.validator),
]

SingleUserLock.created.validator = common.DropboxTimestamp_validator
SingleUserLock.lock_holder_account_id.validator = users_common.AccountId_validator
SingleUserLock.lock_holder_team_id.validator = bv.Nullable(bv.String())
SingleUserLock._all_field_names_ = set(
    [
        "created",
        "lock_holder_account_id",
        "lock_holder_team_id",
    ]
)
SingleUserLock._all_fields_ = [
    ("created", SingleUserLock.created.validator),
    ("lock_holder_account_id", SingleUserLock.lock_holder_account_id.validator),
    ("lock_holder_team_id", SingleUserLock.lock_holder_team_id.validator),
]

SymlinkInfo.target.validator = bv.String()
SymlinkInfo._all_field_names_ = set(["target"])
SymlinkInfo._all_fields_ = [("target", SymlinkInfo.target.validator)]

SyncSetting._default_validator = bv.Void()
SyncSetting._not_synced_validator = bv.Void()
SyncSetting._not_synced_inactive_validator = bv.Void()
SyncSetting._other_validator = bv.Void()
SyncSetting._tagmap = {
    "default": SyncSetting._default_validator,
    "not_synced": SyncSetting._not_synced_validator,
    "not_synced_inactive": SyncSetting._not_synced_inactive_validator,
    "other": SyncSetting._other_validator,
}

SyncSetting.default = SyncSetting("default")
SyncSetting.not_synced = SyncSetting("not_synced")
SyncSetting.not_synced_inactive = SyncSetting("not_synced_inactive")
SyncSetting.other = SyncSetting("other")

SyncSettingArg._default_validator = bv.Void()
SyncSettingArg._not_synced_validator = bv.Void()
SyncSettingArg._other_validator = bv.Void()
SyncSettingArg._tagmap = {
    "default": SyncSettingArg._default_validator,
    "not_synced": SyncSettingArg._not_synced_validator,
    "other": SyncSettingArg._other_validator,
}

SyncSettingArg.default = SyncSettingArg("default")
SyncSettingArg.not_synced = SyncSettingArg("not_synced")
SyncSettingArg.other = SyncSettingArg("other")

SyncSettingsError._path_validator = LookupError_validator
SyncSettingsError._unsupported_combination_validator = bv.Void()
SyncSettingsError._unsupported_configuration_validator = bv.Void()
SyncSettingsError._other_validator = bv.Void()
SyncSettingsError._tagmap = {
    "path": SyncSettingsError._path_validator,
    "unsupported_combination": SyncSettingsError._unsupported_combination_validator,
    "unsupported_configuration": SyncSettingsError._unsupported_configuration_validator,
    "other": SyncSettingsError._other_validator,
}

SyncSettingsError.unsupported_combination = SyncSettingsError("unsupported_combination")
SyncSettingsError.unsupported_configuration = SyncSettingsError("unsupported_configuration")
SyncSettingsError.other = SyncSettingsError("other")

Tag._user_generated_tag_validator = UserGeneratedTag_validator
Tag._other_validator = bv.Void()
Tag._tagmap = {
    "user_generated_tag": Tag._user_generated_tag_validator,
    "other": Tag._other_validator,
}

Tag.other = Tag("other")

ThumbnailArg.path.validator = ReadPath_validator
ThumbnailArg.format.validator = ThumbnailFormat_validator
ThumbnailArg.size.validator = ThumbnailSize_validator
ThumbnailArg.mode.validator = ThumbnailMode_validator
ThumbnailArg.quality.validator = ThumbnailQuality_validator
ThumbnailArg.exclude_media_info.validator = bv.Nullable(bv.Boolean())
ThumbnailArg._all_field_names_ = set(
    [
        "path",
        "format",
        "size",
        "mode",
        "exclude_media_info",
    ]
)
ThumbnailArg._all_fields_ = [
    ("path", ThumbnailArg.path.validator),
    ("format", ThumbnailArg.format.validator),
    ("size", ThumbnailArg.size.validator),
    ("mode", ThumbnailArg.mode.validator),
    ("exclude_media_info", ThumbnailArg.exclude_media_info.validator),
]
ThumbnailArg._all_internal_field_names_ = set(["quality"])
ThumbnailArg._all_internal_fields_ = [("quality", ThumbnailArg.quality.validator)]

ThumbnailError._path_validator = LookupError_validator
ThumbnailError._unsupported_extension_validator = bv.Void()
ThumbnailError._unsupported_image_validator = bv.Void()
ThumbnailError._encrypted_content_validator = bv.Void()
ThumbnailError._conversion_error_validator = bv.Void()
ThumbnailError._tagmap = {
    "path": ThumbnailError._path_validator,
    "unsupported_extension": ThumbnailError._unsupported_extension_validator,
    "unsupported_image": ThumbnailError._unsupported_image_validator,
    "encrypted_content": ThumbnailError._encrypted_content_validator,
    "conversion_error": ThumbnailError._conversion_error_validator,
}

ThumbnailError.unsupported_extension = ThumbnailError("unsupported_extension")
ThumbnailError.unsupported_image = ThumbnailError("unsupported_image")
ThumbnailError.encrypted_content = ThumbnailError("encrypted_content")
ThumbnailError.conversion_error = ThumbnailError("conversion_error")

ThumbnailFormat._jpeg_validator = bv.Void()
ThumbnailFormat._png_validator = bv.Void()
ThumbnailFormat._webp_validator = bv.Void()
ThumbnailFormat._tagmap = {
    "jpeg": ThumbnailFormat._jpeg_validator,
    "png": ThumbnailFormat._png_validator,
    "webp": ThumbnailFormat._webp_validator,
}

ThumbnailFormat.jpeg = ThumbnailFormat("jpeg")
ThumbnailFormat.png = ThumbnailFormat("png")
ThumbnailFormat.webp = ThumbnailFormat("webp")

ThumbnailMode._strict_validator = bv.Void()
ThumbnailMode._bestfit_validator = bv.Void()
ThumbnailMode._fitone_bestfit_validator = bv.Void()
ThumbnailMode._original_validator = bv.Void()
ThumbnailMode._tagmap = {
    "strict": ThumbnailMode._strict_validator,
    "bestfit": ThumbnailMode._bestfit_validator,
    "fitone_bestfit": ThumbnailMode._fitone_bestfit_validator,
    "original": ThumbnailMode._original_validator,
}

ThumbnailMode.strict = ThumbnailMode("strict")
ThumbnailMode.bestfit = ThumbnailMode("bestfit")
ThumbnailMode.fitone_bestfit = ThumbnailMode("fitone_bestfit")
ThumbnailMode.original = ThumbnailMode("original")

ThumbnailQuality._quality_80_validator = bv.Void()
ThumbnailQuality._quality_90_validator = bv.Void()
ThumbnailQuality._tagmap = {
    "quality_80": ThumbnailQuality._quality_80_validator,
    "quality_90": ThumbnailQuality._quality_90_validator,
}

ThumbnailQuality.quality_80 = ThumbnailQuality("quality_80")
ThumbnailQuality.quality_90 = ThumbnailQuality("quality_90")

ThumbnailSize._w32h32_validator = bv.Void()
ThumbnailSize._w64h64_validator = bv.Void()
ThumbnailSize._w128h128_validator = bv.Void()
ThumbnailSize._w256h256_validator = bv.Void()
ThumbnailSize._w480h320_validator = bv.Void()
ThumbnailSize._w640h480_validator = bv.Void()
ThumbnailSize._w960h640_validator = bv.Void()
ThumbnailSize._w1024h768_validator = bv.Void()
ThumbnailSize._w2048h1536_validator = bv.Void()
ThumbnailSize._w3200h2400_validator = bv.Void()
ThumbnailSize._permissioned_tagmaps = {"internal"}
ThumbnailSize._tagmap = {
    "w32h32": ThumbnailSize._w32h32_validator,
    "w64h64": ThumbnailSize._w64h64_validator,
    "w128h128": ThumbnailSize._w128h128_validator,
    "w256h256": ThumbnailSize._w256h256_validator,
    "w480h320": ThumbnailSize._w480h320_validator,
    "w640h480": ThumbnailSize._w640h480_validator,
    "w960h640": ThumbnailSize._w960h640_validator,
    "w1024h768": ThumbnailSize._w1024h768_validator,
    "w2048h1536": ThumbnailSize._w2048h1536_validator,
}
ThumbnailSize._internal_tagmap = {
    "w3200h2400": ThumbnailSize._w3200h2400_validator,
}

ThumbnailSize.w32h32 = ThumbnailSize("w32h32")
ThumbnailSize.w64h64 = ThumbnailSize("w64h64")
ThumbnailSize.w128h128 = ThumbnailSize("w128h128")
ThumbnailSize.w256h256 = ThumbnailSize("w256h256")
ThumbnailSize.w480h320 = ThumbnailSize("w480h320")
ThumbnailSize.w640h480 = ThumbnailSize("w640h480")
ThumbnailSize.w960h640 = ThumbnailSize("w960h640")
ThumbnailSize.w1024h768 = ThumbnailSize("w1024h768")
ThumbnailSize.w2048h1536 = ThumbnailSize("w2048h1536")
ThumbnailSize.w3200h2400 = ThumbnailSize("w3200h2400")

ThumbnailV2Arg.resource.validator = PathOrLink_validator
ThumbnailV2Arg.format.validator = ThumbnailFormat_validator
ThumbnailV2Arg.size.validator = ThumbnailSize_validator
ThumbnailV2Arg.mode.validator = ThumbnailMode_validator
ThumbnailV2Arg.quality.validator = ThumbnailQuality_validator
ThumbnailV2Arg.exclude_media_info.validator = bv.Nullable(bv.Boolean())
ThumbnailV2Arg._all_field_names_ = set(
    [
        "resource",
        "format",
        "size",
        "mode",
        "exclude_media_info",
    ]
)
ThumbnailV2Arg._all_fields_ = [
    ("resource", ThumbnailV2Arg.resource.validator),
    ("format", ThumbnailV2Arg.format.validator),
    ("size", ThumbnailV2Arg.size.validator),
    ("mode", ThumbnailV2Arg.mode.validator),
    ("exclude_media_info", ThumbnailV2Arg.exclude_media_info.validator),
]
ThumbnailV2Arg._all_internal_field_names_ = set(["quality"])
ThumbnailV2Arg._all_internal_fields_ = [("quality", ThumbnailV2Arg.quality.validator)]

ThumbnailV2Error._path_validator = LookupError_validator
ThumbnailV2Error._unsupported_extension_validator = bv.Void()
ThumbnailV2Error._unsupported_image_validator = bv.Void()
ThumbnailV2Error._encrypted_content_validator = bv.Void()
ThumbnailV2Error._conversion_error_validator = bv.Void()
ThumbnailV2Error._access_denied_validator = bv.Void()
ThumbnailV2Error._not_found_validator = bv.Void()
ThumbnailV2Error._other_validator = bv.Void()
ThumbnailV2Error._tagmap = {
    "path": ThumbnailV2Error._path_validator,
    "unsupported_extension": ThumbnailV2Error._unsupported_extension_validator,
    "unsupported_image": ThumbnailV2Error._unsupported_image_validator,
    "encrypted_content": ThumbnailV2Error._encrypted_content_validator,
    "conversion_error": ThumbnailV2Error._conversion_error_validator,
    "access_denied": ThumbnailV2Error._access_denied_validator,
    "not_found": ThumbnailV2Error._not_found_validator,
    "other": ThumbnailV2Error._other_validator,
}

ThumbnailV2Error.unsupported_extension = ThumbnailV2Error("unsupported_extension")
ThumbnailV2Error.unsupported_image = ThumbnailV2Error("unsupported_image")
ThumbnailV2Error.encrypted_content = ThumbnailV2Error("encrypted_content")
ThumbnailV2Error.conversion_error = ThumbnailV2Error("conversion_error")
ThumbnailV2Error.access_denied = ThumbnailV2Error("access_denied")
ThumbnailV2Error.not_found = ThumbnailV2Error("not_found")
ThumbnailV2Error.other = ThumbnailV2Error("other")

UnlockFileArg.path.validator = WritePathOrId_validator
UnlockFileArg._all_field_names_ = set(["path"])
UnlockFileArg._all_fields_ = [("path", UnlockFileArg.path.validator)]

UnlockFileBatchArg.entries.validator = bv.List(UnlockFileArg_validator)
UnlockFileBatchArg._all_field_names_ = set(["entries"])
UnlockFileBatchArg._all_fields_ = [("entries", UnlockFileBatchArg.entries.validator)]

UploadArg.content_hash.validator = bv.Nullable(Sha256HexHash_validator)
UploadArg._all_field_names_ = CommitInfo._all_field_names_.union(set(["content_hash"]))
UploadArg._all_fields_ = CommitInfo._all_fields_ + [
    ("content_hash", UploadArg.content_hash.validator)
]

UploadError._path_validator = UploadWriteFailed_validator
UploadError._properties_error_validator = file_properties.InvalidPropertyGroupError_validator
UploadError._payload_too_large_validator = bv.Void()
UploadError._content_hash_mismatch_validator = bv.Void()
UploadError._encryption_not_supported_validator = bv.Void()
UploadError._other_validator = bv.Void()
UploadError._tagmap = {
    "path": UploadError._path_validator,
    "properties_error": UploadError._properties_error_validator,
    "payload_too_large": UploadError._payload_too_large_validator,
    "content_hash_mismatch": UploadError._content_hash_mismatch_validator,
    "encryption_not_supported": UploadError._encryption_not_supported_validator,
    "other": UploadError._other_validator,
}

UploadError.payload_too_large = UploadError("payload_too_large")
UploadError.content_hash_mismatch = UploadError("content_hash_mismatch")
UploadError.encryption_not_supported = UploadError("encryption_not_supported")
UploadError.other = UploadError("other")

UploadSessionAppendArg.cursor.validator = UploadSessionCursor_validator
UploadSessionAppendArg.close.validator = bv.Boolean()
UploadSessionAppendArg.content_hash.validator = bv.Nullable(Sha256HexHash_validator)
UploadSessionAppendArg._all_field_names_ = set(
    [
        "cursor",
        "close",
        "content_hash",
    ]
)
UploadSessionAppendArg._all_fields_ = [
    ("cursor", UploadSessionAppendArg.cursor.validator),
    ("close", UploadSessionAppendArg.close.validator),
    ("content_hash", UploadSessionAppendArg.content_hash.validator),
]

UploadSessionAppendBatchArg.entries.validator = bv.List(
    UploadSessionAppendBatchArgEntry_validator, max_items=1000
)
UploadSessionAppendBatchArg.content_hash.validator = bv.Nullable(Sha256HexHash_validator)
UploadSessionAppendBatchArg._all_field_names_ = set(
    [
        "entries",
        "content_hash",
    ]
)
UploadSessionAppendBatchArg._all_fields_ = [
    ("entries", UploadSessionAppendBatchArg.entries.validator),
    ("content_hash", UploadSessionAppendBatchArg.content_hash.validator),
]

UploadSessionAppendBatchArgEntry.cursor.validator = UploadSessionCursor_validator
UploadSessionAppendBatchArgEntry.length.validator = bv.UInt64()
UploadSessionAppendBatchArgEntry.close.validator = bv.Boolean()
UploadSessionAppendBatchArgEntry._all_field_names_ = set(
    [
        "cursor",
        "length",
        "close",
    ]
)
UploadSessionAppendBatchArgEntry._all_fields_ = [
    ("cursor", UploadSessionAppendBatchArgEntry.cursor.validator),
    ("length", UploadSessionAppendBatchArgEntry.length.validator),
    ("close", UploadSessionAppendBatchArgEntry.close.validator),
]

UploadSessionAppendBatchEntryError._not_found_validator = bv.Void()
UploadSessionAppendBatchEntryError._incorrect_offset_validator = UploadSessionOffsetError_validator
UploadSessionAppendBatchEntryError._closed_validator = bv.Void()
UploadSessionAppendBatchEntryError._too_large_validator = bv.Void()
UploadSessionAppendBatchEntryError._concurrent_session_invalid_offset_validator = bv.Void()
UploadSessionAppendBatchEntryError._concurrent_session_invalid_data_size_validator = bv.Void()
UploadSessionAppendBatchEntryError._other_validator = bv.Void()
UploadSessionAppendBatchEntryError._tagmap = {
    "not_found": UploadSessionAppendBatchEntryError._not_found_validator,
    "incorrect_offset": UploadSessionAppendBatchEntryError._incorrect_offset_validator,
    "closed": UploadSessionAppendBatchEntryError._closed_validator,
    "too_large": UploadSessionAppendBatchEntryError._too_large_validator,
    "concurrent_session_invalid_offset": UploadSessionAppendBatchEntryError._concurrent_session_invalid_offset_validator,
    "concurrent_session_invalid_data_size": UploadSessionAppendBatchEntryError._concurrent_session_invalid_data_size_validator,
    "other": UploadSessionAppendBatchEntryError._other_validator,
}

UploadSessionAppendBatchEntryError.not_found = UploadSessionAppendBatchEntryError("not_found")
UploadSessionAppendBatchEntryError.closed = UploadSessionAppendBatchEntryError("closed")
UploadSessionAppendBatchEntryError.too_large = UploadSessionAppendBatchEntryError("too_large")
UploadSessionAppendBatchEntryError.concurrent_session_invalid_offset = (
    UploadSessionAppendBatchEntryError("concurrent_session_invalid_offset")
)
UploadSessionAppendBatchEntryError.concurrent_session_invalid_data_size = (
    UploadSessionAppendBatchEntryError("concurrent_session_invalid_data_size")
)
UploadSessionAppendBatchEntryError.other = UploadSessionAppendBatchEntryError("other")

UploadSessionAppendBatchError._payload_too_large_validator = bv.Void()
UploadSessionAppendBatchError._content_hash_mismatch_validator = bv.Void()
UploadSessionAppendBatchError._length_mismatch_validator = bv.Void()
UploadSessionAppendBatchError._other_validator = bv.Void()
UploadSessionAppendBatchError._tagmap = {
    "payload_too_large": UploadSessionAppendBatchError._payload_too_large_validator,
    "content_hash_mismatch": UploadSessionAppendBatchError._content_hash_mismatch_validator,
    "length_mismatch": UploadSessionAppendBatchError._length_mismatch_validator,
    "other": UploadSessionAppendBatchError._other_validator,
}

UploadSessionAppendBatchError.payload_too_large = UploadSessionAppendBatchError("payload_too_large")
UploadSessionAppendBatchError.content_hash_mismatch = UploadSessionAppendBatchError(
    "content_hash_mismatch"
)
UploadSessionAppendBatchError.length_mismatch = UploadSessionAppendBatchError("length_mismatch")
UploadSessionAppendBatchError.other = UploadSessionAppendBatchError("other")

UploadSessionAppendBatchResult.entries.validator = bv.List(
    UploadSessionAppendBatchResultEntry_validator
)
UploadSessionAppendBatchResult._all_field_names_ = set(["entries"])
UploadSessionAppendBatchResult._all_fields_ = [
    ("entries", UploadSessionAppendBatchResult.entries.validator)
]

UploadSessionAppendBatchResultEntry._success_validator = bv.Void()
UploadSessionAppendBatchResultEntry._failure_validator = (
    UploadSessionAppendBatchEntryError_validator
)
UploadSessionAppendBatchResultEntry._tagmap = {
    "success": UploadSessionAppendBatchResultEntry._success_validator,
    "failure": UploadSessionAppendBatchResultEntry._failure_validator,
}

UploadSessionAppendBatchResultEntry.success = UploadSessionAppendBatchResultEntry("success")

UploadSessionAppendError._not_found_validator = bv.Void()
UploadSessionAppendError._incorrect_offset_validator = UploadSessionOffsetError_validator
UploadSessionAppendError._closed_validator = bv.Void()
UploadSessionAppendError._too_large_validator = bv.Void()
UploadSessionAppendError._concurrent_session_invalid_offset_validator = bv.Void()
UploadSessionAppendError._concurrent_session_invalid_data_size_validator = bv.Void()
UploadSessionAppendError._payload_too_large_validator = bv.Void()
UploadSessionAppendError._content_hash_mismatch_validator = bv.Void()
UploadSessionAppendError._other_validator = bv.Void()
UploadSessionAppendError._tagmap = {
    "not_found": UploadSessionAppendError._not_found_validator,
    "incorrect_offset": UploadSessionAppendError._incorrect_offset_validator,
    "closed": UploadSessionAppendError._closed_validator,
    "too_large": UploadSessionAppendError._too_large_validator,
    "concurrent_session_invalid_offset": UploadSessionAppendError._concurrent_session_invalid_offset_validator,
    "concurrent_session_invalid_data_size": UploadSessionAppendError._concurrent_session_invalid_data_size_validator,
    "payload_too_large": UploadSessionAppendError._payload_too_large_validator,
    "content_hash_mismatch": UploadSessionAppendError._content_hash_mismatch_validator,
    "other": UploadSessionAppendError._other_validator,
}

UploadSessionAppendError.not_found = UploadSessionAppendError("not_found")
UploadSessionAppendError.closed = UploadSessionAppendError("closed")
UploadSessionAppendError.too_large = UploadSessionAppendError("too_large")
UploadSessionAppendError.concurrent_session_invalid_offset = UploadSessionAppendError(
    "concurrent_session_invalid_offset"
)
UploadSessionAppendError.concurrent_session_invalid_data_size = UploadSessionAppendError(
    "concurrent_session_invalid_data_size"
)
UploadSessionAppendError.payload_too_large = UploadSessionAppendError("payload_too_large")
UploadSessionAppendError.content_hash_mismatch = UploadSessionAppendError("content_hash_mismatch")
UploadSessionAppendError.other = UploadSessionAppendError("other")

UploadSessionCursor.session_id.validator = bv.String()
UploadSessionCursor.offset.validator = bv.UInt64()
UploadSessionCursor._all_field_names_ = set(
    [
        "session_id",
        "offset",
    ]
)
UploadSessionCursor._all_fields_ = [
    ("session_id", UploadSessionCursor.session_id.validator),
    ("offset", UploadSessionCursor.offset.validator),
]

UploadSessionFinishArg.cursor.validator = UploadSessionCursor_validator
UploadSessionFinishArg.commit.validator = CommitInfo_validator
UploadSessionFinishArg.content_hash.validator = bv.Nullable(Sha256HexHash_validator)
UploadSessionFinishArg._all_field_names_ = set(
    [
        "cursor",
        "commit",
        "content_hash",
    ]
)
UploadSessionFinishArg._all_fields_ = [
    ("cursor", UploadSessionFinishArg.cursor.validator),
    ("commit", UploadSessionFinishArg.commit.validator),
    ("content_hash", UploadSessionFinishArg.content_hash.validator),
]

UploadSessionFinishBatchArg.entries.validator = bv.List(
    UploadSessionFinishArg_validator, max_items=1000
)
UploadSessionFinishBatchArg._all_field_names_ = set(["entries"])
UploadSessionFinishBatchArg._all_fields_ = [
    ("entries", UploadSessionFinishBatchArg.entries.validator)
]

UploadSessionFinishBatchJobStatus._complete_validator = UploadSessionFinishBatchResult_validator
UploadSessionFinishBatchJobStatus._tagmap = {
    "complete": UploadSessionFinishBatchJobStatus._complete_validator,
}
UploadSessionFinishBatchJobStatus._tagmap.update(async_.PollResultBase._tagmap)

UploadSessionFinishBatchLaunch._complete_validator = UploadSessionFinishBatchResult_validator
UploadSessionFinishBatchLaunch._other_validator = bv.Void()
UploadSessionFinishBatchLaunch._tagmap = {
    "complete": UploadSessionFinishBatchLaunch._complete_validator,
    "other": UploadSessionFinishBatchLaunch._other_validator,
}
UploadSessionFinishBatchLaunch._tagmap.update(async_.LaunchResultBase._tagmap)

UploadSessionFinishBatchLaunch.other = UploadSessionFinishBatchLaunch("other")

UploadSessionFinishBatchResult.entries.validator = bv.List(
    UploadSessionFinishBatchResultEntry_validator
)
UploadSessionFinishBatchResult._all_field_names_ = set(["entries"])
UploadSessionFinishBatchResult._all_fields_ = [
    ("entries", UploadSessionFinishBatchResult.entries.validator)
]

UploadSessionFinishBatchResultEntry._success_validator = FileMetadata_validator
UploadSessionFinishBatchResultEntry._failure_validator = UploadSessionFinishError_validator
UploadSessionFinishBatchResultEntry._tagmap = {
    "success": UploadSessionFinishBatchResultEntry._success_validator,
    "failure": UploadSessionFinishBatchResultEntry._failure_validator,
}

UploadSessionFinishError._lookup_failed_validator = UploadSessionLookupError_validator
UploadSessionFinishError._path_validator = WriteError_validator
UploadSessionFinishError._properties_error_validator = (
    file_properties.InvalidPropertyGroupError_validator
)
UploadSessionFinishError._too_many_shared_folder_targets_validator = bv.Void()
UploadSessionFinishError._too_many_write_operations_validator = bv.Void()
UploadSessionFinishError._concurrent_session_data_not_allowed_validator = bv.Void()
UploadSessionFinishError._concurrent_session_not_closed_validator = bv.Void()
UploadSessionFinishError._concurrent_session_missing_data_validator = bv.Void()
UploadSessionFinishError._payload_too_large_validator = bv.Void()
UploadSessionFinishError._content_hash_mismatch_validator = bv.Void()
UploadSessionFinishError._encryption_not_supported_validator = bv.Void()
UploadSessionFinishError._other_validator = bv.Void()
UploadSessionFinishError._tagmap = {
    "lookup_failed": UploadSessionFinishError._lookup_failed_validator,
    "path": UploadSessionFinishError._path_validator,
    "properties_error": UploadSessionFinishError._properties_error_validator,
    "too_many_shared_folder_targets": UploadSessionFinishError._too_many_shared_folder_targets_validator,
    "too_many_write_operations": UploadSessionFinishError._too_many_write_operations_validator,
    "concurrent_session_data_not_allowed": UploadSessionFinishError._concurrent_session_data_not_allowed_validator,
    "concurrent_session_not_closed": UploadSessionFinishError._concurrent_session_not_closed_validator,
    "concurrent_session_missing_data": UploadSessionFinishError._concurrent_session_missing_data_validator,
    "payload_too_large": UploadSessionFinishError._payload_too_large_validator,
    "content_hash_mismatch": UploadSessionFinishError._content_hash_mismatch_validator,
    "encryption_not_supported": UploadSessionFinishError._encryption_not_supported_validator,
    "other": UploadSessionFinishError._other_validator,
}

UploadSessionFinishError.too_many_shared_folder_targets = UploadSessionFinishError(
    "too_many_shared_folder_targets"
)
UploadSessionFinishError.too_many_write_operations = UploadSessionFinishError(
    "too_many_write_operations"
)
UploadSessionFinishError.concurrent_session_data_not_allowed = UploadSessionFinishError(
    "concurrent_session_data_not_allowed"
)
UploadSessionFinishError.concurrent_session_not_closed = UploadSessionFinishError(
    "concurrent_session_not_closed"
)
UploadSessionFinishError.concurrent_session_missing_data = UploadSessionFinishError(
    "concurrent_session_missing_data"
)
UploadSessionFinishError.payload_too_large = UploadSessionFinishError("payload_too_large")
UploadSessionFinishError.content_hash_mismatch = UploadSessionFinishError("content_hash_mismatch")
UploadSessionFinishError.encryption_not_supported = UploadSessionFinishError(
    "encryption_not_supported"
)
UploadSessionFinishError.other = UploadSessionFinishError("other")

UploadSessionLookupError._not_found_validator = bv.Void()
UploadSessionLookupError._incorrect_offset_validator = UploadSessionOffsetError_validator
UploadSessionLookupError._closed_validator = bv.Void()
UploadSessionLookupError._not_closed_validator = bv.Void()
UploadSessionLookupError._too_large_validator = bv.Void()
UploadSessionLookupError._concurrent_session_invalid_offset_validator = bv.Void()
UploadSessionLookupError._concurrent_session_invalid_data_size_validator = bv.Void()
UploadSessionLookupError._payload_too_large_validator = bv.Void()
UploadSessionLookupError._other_validator = bv.Void()
UploadSessionLookupError._tagmap = {
    "not_found": UploadSessionLookupError._not_found_validator,
    "incorrect_offset": UploadSessionLookupError._incorrect_offset_validator,
    "closed": UploadSessionLookupError._closed_validator,
    "not_closed": UploadSessionLookupError._not_closed_validator,
    "too_large": UploadSessionLookupError._too_large_validator,
    "concurrent_session_invalid_offset": UploadSessionLookupError._concurrent_session_invalid_offset_validator,
    "concurrent_session_invalid_data_size": UploadSessionLookupError._concurrent_session_invalid_data_size_validator,
    "payload_too_large": UploadSessionLookupError._payload_too_large_validator,
    "other": UploadSessionLookupError._other_validator,
}

UploadSessionLookupError.not_found = UploadSessionLookupError("not_found")
UploadSessionLookupError.closed = UploadSessionLookupError("closed")
UploadSessionLookupError.not_closed = UploadSessionLookupError("not_closed")
UploadSessionLookupError.too_large = UploadSessionLookupError("too_large")
UploadSessionLookupError.concurrent_session_invalid_offset = UploadSessionLookupError(
    "concurrent_session_invalid_offset"
)
UploadSessionLookupError.concurrent_session_invalid_data_size = UploadSessionLookupError(
    "concurrent_session_invalid_data_size"
)
UploadSessionLookupError.payload_too_large = UploadSessionLookupError("payload_too_large")
UploadSessionLookupError.other = UploadSessionLookupError("other")

UploadSessionOffsetError.correct_offset.validator = bv.UInt64()
UploadSessionOffsetError._all_field_names_ = set(["correct_offset"])
UploadSessionOffsetError._all_fields_ = [
    ("correct_offset", UploadSessionOffsetError.correct_offset.validator)
]

UploadSessionStartArg.close.validator = bv.Boolean()
UploadSessionStartArg.session_type.validator = bv.Nullable(UploadSessionType_validator)
UploadSessionStartArg.content_hash.validator = bv.Nullable(Sha256HexHash_validator)
UploadSessionStartArg._all_field_names_ = set(
    [
        "close",
        "session_type",
        "content_hash",
    ]
)
UploadSessionStartArg._all_fields_ = [
    ("close", UploadSessionStartArg.close.validator),
    ("session_type", UploadSessionStartArg.session_type.validator),
    ("content_hash", UploadSessionStartArg.content_hash.validator),
]

UploadSessionStartBatchArg.session_type.validator = bv.Nullable(UploadSessionType_validator)
UploadSessionStartBatchArg.num_sessions.validator = bv.UInt64(min_value=1, max_value=1000)
UploadSessionStartBatchArg._all_field_names_ = set(
    [
        "session_type",
        "num_sessions",
    ]
)
UploadSessionStartBatchArg._all_fields_ = [
    ("session_type", UploadSessionStartBatchArg.session_type.validator),
    ("num_sessions", UploadSessionStartBatchArg.num_sessions.validator),
]

UploadSessionStartBatchResult.session_ids.validator = bv.List(bv.String())
UploadSessionStartBatchResult._all_field_names_ = set(["session_ids"])
UploadSessionStartBatchResult._all_fields_ = [
    ("session_ids", UploadSessionStartBatchResult.session_ids.validator)
]

UploadSessionStartError._concurrent_session_data_not_allowed_validator = bv.Void()
UploadSessionStartError._concurrent_session_close_not_allowed_validator = bv.Void()
UploadSessionStartError._payload_too_large_validator = bv.Void()
UploadSessionStartError._content_hash_mismatch_validator = bv.Void()
UploadSessionStartError._other_validator = bv.Void()
UploadSessionStartError._tagmap = {
    "concurrent_session_data_not_allowed": UploadSessionStartError._concurrent_session_data_not_allowed_validator,
    "concurrent_session_close_not_allowed": UploadSessionStartError._concurrent_session_close_not_allowed_validator,
    "payload_too_large": UploadSessionStartError._payload_too_large_validator,
    "content_hash_mismatch": UploadSessionStartError._content_hash_mismatch_validator,
    "other": UploadSessionStartError._other_validator,
}

UploadSessionStartError.concurrent_session_data_not_allowed = UploadSessionStartError(
    "concurrent_session_data_not_allowed"
)
UploadSessionStartError.concurrent_session_close_not_allowed = UploadSessionStartError(
    "concurrent_session_close_not_allowed"
)
UploadSessionStartError.payload_too_large = UploadSessionStartError("payload_too_large")
UploadSessionStartError.content_hash_mismatch = UploadSessionStartError("content_hash_mismatch")
UploadSessionStartError.other = UploadSessionStartError("other")

UploadSessionStartResult.session_id.validator = bv.String()
UploadSessionStartResult._all_field_names_ = set(["session_id"])
UploadSessionStartResult._all_fields_ = [
    ("session_id", UploadSessionStartResult.session_id.validator)
]

UploadSessionType._sequential_validator = bv.Void()
UploadSessionType._concurrent_validator = bv.Void()
UploadSessionType._other_validator = bv.Void()
UploadSessionType._tagmap = {
    "sequential": UploadSessionType._sequential_validator,
    "concurrent": UploadSessionType._concurrent_validator,
    "other": UploadSessionType._other_validator,
}

UploadSessionType.sequential = UploadSessionType("sequential")
UploadSessionType.concurrent = UploadSessionType("concurrent")
UploadSessionType.other = UploadSessionType("other")

UploadWriteFailed.reason.validator = WriteError_validator
UploadWriteFailed.upload_session_id.validator = bv.String()
UploadWriteFailed._all_field_names_ = set(
    [
        "reason",
        "upload_session_id",
    ]
)
UploadWriteFailed._all_fields_ = [
    ("reason", UploadWriteFailed.reason.validator),
    ("upload_session_id", UploadWriteFailed.upload_session_id.validator),
]

UserGeneratedTag.tag_text.validator = TagText_validator
UserGeneratedTag._all_field_names_ = set(["tag_text"])
UserGeneratedTag._all_fields_ = [("tag_text", UserGeneratedTag.tag_text.validator)]

VideoMetadata.duration.validator = bv.Nullable(bv.UInt64())
VideoMetadata._field_names_ = set(["duration"])
VideoMetadata._all_field_names_ = MediaMetadata._all_field_names_.union(VideoMetadata._field_names_)
VideoMetadata._fields_ = [("duration", VideoMetadata.duration.validator)]
VideoMetadata._all_fields_ = MediaMetadata._all_fields_ + VideoMetadata._fields_

WriteConflictError._file_validator = bv.Void()
WriteConflictError._folder_validator = bv.Void()
WriteConflictError._file_ancestor_validator = bv.Void()
WriteConflictError._other_validator = bv.Void()
WriteConflictError._tagmap = {
    "file": WriteConflictError._file_validator,
    "folder": WriteConflictError._folder_validator,
    "file_ancestor": WriteConflictError._file_ancestor_validator,
    "other": WriteConflictError._other_validator,
}

WriteConflictError.file = WriteConflictError("file")
WriteConflictError.folder = WriteConflictError("folder")
WriteConflictError.file_ancestor = WriteConflictError("file_ancestor")
WriteConflictError.other = WriteConflictError("other")

WriteError._malformed_path_validator = MalformedPathError_validator
WriteError._conflict_validator = WriteConflictError_validator
WriteError._no_write_permission_validator = bv.Void()
WriteError._insufficient_space_validator = bv.Void()
WriteError._disallowed_name_validator = bv.Void()
WriteError._team_folder_validator = bv.Void()
WriteError._operation_suppressed_validator = bv.Void()
WriteError._too_many_write_operations_validator = bv.Void()
WriteError._access_restricted_validator = bv.Void()
WriteError._other_validator = bv.Void()
WriteError._tagmap = {
    "malformed_path": WriteError._malformed_path_validator,
    "conflict": WriteError._conflict_validator,
    "no_write_permission": WriteError._no_write_permission_validator,
    "insufficient_space": WriteError._insufficient_space_validator,
    "disallowed_name": WriteError._disallowed_name_validator,
    "team_folder": WriteError._team_folder_validator,
    "operation_suppressed": WriteError._operation_suppressed_validator,
    "too_many_write_operations": WriteError._too_many_write_operations_validator,
    "access_restricted": WriteError._access_restricted_validator,
    "other": WriteError._other_validator,
}

WriteError.no_write_permission = WriteError("no_write_permission")
WriteError.insufficient_space = WriteError("insufficient_space")
WriteError.disallowed_name = WriteError("disallowed_name")
WriteError.team_folder = WriteError("team_folder")
WriteError.operation_suppressed = WriteError("operation_suppressed")
WriteError.too_many_write_operations = WriteError("too_many_write_operations")
WriteError.access_restricted = WriteError("access_restricted")
WriteError.other = WriteError("other")

WriteMode._add_validator = bv.Void()
WriteMode._overwrite_validator = bv.Void()
WriteMode._update_validator = Rev_validator
WriteMode._tagmap = {
    "add": WriteMode._add_validator,
    "overwrite": WriteMode._overwrite_validator,
    "update": WriteMode._update_validator,
}

WriteMode.add = WriteMode("add")
WriteMode.overwrite = WriteMode("overwrite")

GetMetadataArg.include_media_info.default = False
GetMetadataArg.include_deleted.default = False
GetMetadataArg.include_has_explicit_shared_members.default = False
CommitInfo.mode.default = WriteMode.add
CommitInfo.autorename.default = False
CommitInfo.mute.default = False
CommitInfo.strict_conflict.default = False
CreateFolderArg.autorename.default = False
CreateFolderBatchArg.autorename.default = False
CreateFolderBatchArg.force_async.default = False
FileMetadata.is_downloadable.default = True
FolderSharingInfo.traverse_only.default = False
FolderSharingInfo.no_access.default = False
GetTemporaryUploadLinkArg.duration.default = 14400.0
ListFolderArg.recursive.default = False
ListFolderArg.include_media_info.default = False
ListFolderArg.include_deleted.default = False
ListFolderArg.include_has_explicit_shared_members.default = False
ListFolderArg.include_mounted_folders.default = True
ListFolderArg.include_non_downloadable_files.default = True
ListFolderArg.include_restorable_info.default = False
ListFolderLongpollArg.timeout.default = 30
ListRevisionsArg.mode.default = ListRevisionsMode.path
ListRevisionsArg.limit.default = 10
ListRevisionsArg.include_restorable_info.default = False
RelocationBatchArgBase.autorename.default = False
MoveBatchArg.allow_ownership_transfer.default = False
RelocationArg.allow_shared_folder.default = False
RelocationArg.autorename.default = False
RelocationArg.allow_ownership_transfer.default = False
RelocationBatchArg.allow_shared_folder.default = False
RelocationBatchArg.allow_ownership_transfer.default = False
SearchArg.start.default = 0
SearchArg.max_results.default = 100
SearchArg.mode.default = SearchMode.filename
SearchMatchFieldOptions.include_highlights.default = False
SearchOptions.max_results.default = 100
SearchOptions.file_status.default = FileStatus.active
SearchOptions.filename_only.default = False
ThumbnailArg.format.default = ThumbnailFormat.jpeg
ThumbnailArg.size.default = ThumbnailSize.w64h64
ThumbnailArg.mode.default = ThumbnailMode.strict
ThumbnailArg.quality.default = ThumbnailQuality.quality_80
ThumbnailV2Arg.format.default = ThumbnailFormat.jpeg
ThumbnailV2Arg.size.default = ThumbnailSize.w64h64
ThumbnailV2Arg.mode.default = ThumbnailMode.strict
ThumbnailV2Arg.quality.default = ThumbnailQuality.quality_80
UploadSessionAppendArg.close.default = False
UploadSessionAppendBatchArgEntry.close.default = False
UploadSessionStartArg.close.default = False
alpha_get_metadata = bb.Route(
    "alpha/get_metadata",
    1,
    True,
    AlphaGetMetadataArg_validator,
    Metadata_validator,
    AlphaGetMetadataError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
alpha_upload = bb.Route(
    "alpha/upload",
    1,
    True,
    UploadArg_validator,
    FileMetadata_validator,
    UploadError_validator,
    {"auth": "user", "host": "content", "style": "upload"},
)
copy = bb.Route(
    "copy",
    1,
    True,
    RelocationArg_validator,
    Metadata_validator,
    RelocationError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
copy_v2 = bb.Route(
    "copy",
    2,
    False,
    RelocationArg_validator,
    RelocationResult_validator,
    RelocationError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
copy_batch = bb.Route(
    "copy_batch",
    1,
    True,
    RelocationBatchArg_validator,
    RelocationBatchLaunch_validator,
    bv.Void(),
    {"auth": "user", "host": "api", "style": "rpc"},
)
copy_batch_v2 = bb.Route(
    "copy_batch",
    2,
    False,
    CopyBatchArg_validator,
    RelocationBatchV2Launch_validator,
    bv.Void(),
    {"auth": "user", "host": "api", "style": "rpc"},
)
copy_batch_check = bb.Route(
    "copy_batch/check",
    1,
    True,
    async_.PollArg_validator,
    RelocationBatchJobStatus_validator,
    async_.PollError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
copy_batch_check_v2 = bb.Route(
    "copy_batch/check",
    2,
    False,
    async_.PollArg_validator,
    RelocationBatchV2JobStatus_validator,
    async_.PollError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
copy_reference_get = bb.Route(
    "copy_reference/get",
    1,
    False,
    GetCopyReferenceArg_validator,
    GetCopyReferenceResult_validator,
    GetCopyReferenceError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
copy_reference_save = bb.Route(
    "copy_reference/save",
    1,
    False,
    SaveCopyReferenceArg_validator,
    SaveCopyReferenceResult_validator,
    SaveCopyReferenceError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
create_folder = bb.Route(
    "create_folder",
    1,
    True,
    CreateFolderArg_validator,
    FolderMetadata_validator,
    CreateFolderError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
create_folder_v2 = bb.Route(
    "create_folder",
    2,
    False,
    CreateFolderArg_validator,
    CreateFolderResult_validator,
    CreateFolderError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
create_folder_batch = bb.Route(
    "create_folder_batch",
    1,
    False,
    CreateFolderBatchArg_validator,
    CreateFolderBatchLaunch_validator,
    bv.Void(),
    {"auth": "user", "host": "api", "style": "rpc"},
)
create_folder_batch_check = bb.Route(
    "create_folder_batch/check",
    1,
    False,
    async_.PollArg_validator,
    CreateFolderBatchJobStatus_validator,
    async_.PollError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
delete = bb.Route(
    "delete",
    1,
    True,
    DeleteArg_validator,
    Metadata_validator,
    DeleteError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
delete_v2 = bb.Route(
    "delete",
    2,
    False,
    DeleteArg_validator,
    DeleteResult_validator,
    DeleteError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
delete_batch = bb.Route(
    "delete_batch",
    1,
    False,
    DeleteBatchArg_validator,
    DeleteBatchLaunch_validator,
    bv.Void(),
    {"auth": "user", "host": "api", "style": "rpc"},
)
delete_batch_check = bb.Route(
    "delete_batch/check",
    1,
    False,
    async_.PollArg_validator,
    DeleteBatchJobStatus_validator,
    async_.PollError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
download = bb.Route(
    "download",
    1,
    False,
    DownloadArg_validator,
    FileMetadata_validator,
    DownloadError_validator,
    {"auth": "user", "host": "content", "style": "download"},
)
download_zip = bb.Route(
    "download_zip",
    1,
    False,
    DownloadZipArg_validator,
    DownloadZipResult_validator,
    DownloadZipError_validator,
    {"auth": "user", "host": "content", "style": "download"},
)
export = bb.Route(
    "export",
    1,
    False,
    ExportArg_validator,
    ExportResult_validator,
    ExportError_validator,
    {"auth": "user", "host": "content", "style": "download"},
)
get_file_lock_batch = bb.Route(
    "get_file_lock_batch",
    1,
    False,
    LockFileBatchArg_validator,
    LockFileBatchResult_validator,
    LockFileError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
get_metadata = bb.Route(
    "get_metadata",
    1,
    False,
    GetMetadataArg_validator,
    Metadata_validator,
    GetMetadataError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
get_preview = bb.Route(
    "get_preview",
    1,
    False,
    PreviewArg_validator,
    FileMetadata_validator,
    PreviewError_validator,
    {"auth": "user", "host": "content", "style": "download"},
)
get_temporary_link = bb.Route(
    "get_temporary_link",
    1,
    False,
    GetTemporaryLinkArg_validator,
    GetTemporaryLinkResult_validator,
    GetTemporaryLinkError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
get_temporary_upload_link = bb.Route(
    "get_temporary_upload_link",
    1,
    False,
    GetTemporaryUploadLinkArg_validator,
    GetTemporaryUploadLinkResult_validator,
    bv.Void(),
    {"auth": "user", "host": "api", "style": "rpc"},
)
get_thumbnail = bb.Route(
    "get_thumbnail",
    1,
    False,
    ThumbnailArg_validator,
    FileMetadata_validator,
    ThumbnailError_validator,
    {"auth": "user", "host": "content", "style": "download"},
)
get_thumbnail_v2 = bb.Route(
    "get_thumbnail",
    2,
    False,
    ThumbnailV2Arg_validator,
    PreviewResult_validator,
    ThumbnailV2Error_validator,
    {"auth": "app, user", "host": "content", "style": "download"},
)
get_thumbnail_batch = bb.Route(
    "get_thumbnail_batch",
    1,
    False,
    GetThumbnailBatchArg_validator,
    GetThumbnailBatchResult_validator,
    GetThumbnailBatchError_validator,
    {"auth": "user", "host": "content", "style": "rpc"},
)
list_folder = bb.Route(
    "list_folder",
    1,
    False,
    ListFolderArg_validator,
    ListFolderResult_validator,
    ListFolderError_validator,
    {"auth": "app, user", "host": "api", "style": "rpc"},
)
list_folder_continue = bb.Route(
    "list_folder/continue",
    1,
    False,
    ListFolderContinueArg_validator,
    ListFolderResult_validator,
    ListFolderContinueError_validator,
    {"auth": "app, user", "host": "api", "style": "rpc"},
)
list_folder_get_latest_cursor = bb.Route(
    "list_folder/get_latest_cursor",
    1,
    False,
    ListFolderArg_validator,
    ListFolderGetLatestCursorResult_validator,
    ListFolderError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
list_folder_longpoll = bb.Route(
    "list_folder/longpoll",
    1,
    False,
    ListFolderLongpollArg_validator,
    ListFolderLongpollResult_validator,
    ListFolderLongpollError_validator,
    {"auth": "noauth", "host": "notify", "style": "rpc"},
)
list_revisions = bb.Route(
    "list_revisions",
    1,
    False,
    ListRevisionsArg_validator,
    ListRevisionsResult_validator,
    ListRevisionsError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
lock_file_batch = bb.Route(
    "lock_file_batch",
    1,
    False,
    LockFileBatchArg_validator,
    LockFileBatchResult_validator,
    LockFileError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
move = bb.Route(
    "move",
    1,
    True,
    RelocationArg_validator,
    Metadata_validator,
    RelocationError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
move_v2 = bb.Route(
    "move",
    2,
    False,
    RelocationArg_validator,
    RelocationResult_validator,
    RelocationError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
move_batch = bb.Route(
    "move_batch",
    1,
    True,
    RelocationBatchArg_validator,
    RelocationBatchLaunch_validator,
    bv.Void(),
    {"auth": "user", "host": "api", "style": "rpc"},
)
move_batch_v2 = bb.Route(
    "move_batch",
    2,
    False,
    MoveBatchArg_validator,
    RelocationBatchV2Launch_validator,
    bv.Void(),
    {"auth": "user", "host": "api", "style": "rpc"},
)
move_batch_check = bb.Route(
    "move_batch/check",
    1,
    True,
    async_.PollArg_validator,
    RelocationBatchJobStatus_validator,
    async_.PollError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
move_batch_check_v2 = bb.Route(
    "move_batch/check",
    2,
    False,
    async_.PollArg_validator,
    RelocationBatchV2JobStatus_validator,
    async_.PollError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
paper_create = bb.Route(
    "paper/create",
    1,
    False,
    PaperCreateArg_validator,
    PaperCreateResult_validator,
    PaperCreateError_validator,
    {"auth": "user", "host": "api", "style": "upload"},
)
paper_update = bb.Route(
    "paper/update",
    1,
    False,
    PaperUpdateArg_validator,
    PaperUpdateResult_validator,
    PaperUpdateError_validator,
    {"auth": "user", "host": "api", "style": "upload"},
)
permanently_delete = bb.Route(
    "permanently_delete",
    1,
    False,
    DeleteArg_validator,
    bv.Void(),
    DeleteError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
properties_add = bb.Route(
    "properties/add",
    1,
    True,
    file_properties.AddPropertiesArg_validator,
    bv.Void(),
    file_properties.AddPropertiesError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
properties_overwrite = bb.Route(
    "properties/overwrite",
    1,
    True,
    file_properties.OverwritePropertyGroupArg_validator,
    bv.Void(),
    file_properties.InvalidPropertyGroupError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
properties_update = bb.Route(
    "properties/update",
    1,
    True,
    file_properties.UpdatePropertiesArg_validator,
    bv.Void(),
    file_properties.UpdatePropertiesError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
restore = bb.Route(
    "restore",
    1,
    False,
    RestoreArg_validator,
    FileMetadata_validator,
    RestoreError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
save_url = bb.Route(
    "save_url",
    1,
    False,
    SaveUrlArg_validator,
    SaveUrlResult_validator,
    SaveUrlError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
save_url_check_job_status = bb.Route(
    "save_url/check_job_status",
    1,
    False,
    async_.PollArg_validator,
    SaveUrlJobStatus_validator,
    async_.PollError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
search = bb.Route(
    "search",
    1,
    True,
    SearchArg_validator,
    SearchResult_validator,
    SearchError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
search_v2 = bb.Route(
    "search",
    2,
    False,
    SearchV2Arg_validator,
    SearchV2Result_validator,
    SearchError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
search_continue_v2 = bb.Route(
    "search/continue",
    2,
    False,
    SearchV2ContinueArg_validator,
    SearchV2Result_validator,
    SearchError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
tags_add = bb.Route(
    "tags/add",
    1,
    False,
    AddTagArg_validator,
    bv.Void(),
    AddTagError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
tags_get = bb.Route(
    "tags/get",
    1,
    False,
    GetTagsArg_validator,
    GetTagsResult_validator,
    BaseTagError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
tags_remove = bb.Route(
    "tags/remove",
    1,
    False,
    RemoveTagArg_validator,
    bv.Void(),
    RemoveTagError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
unlock_file_batch = bb.Route(
    "unlock_file_batch",
    1,
    False,
    UnlockFileBatchArg_validator,
    LockFileBatchResult_validator,
    LockFileError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
upload = bb.Route(
    "upload",
    1,
    False,
    UploadArg_validator,
    FileMetadata_validator,
    UploadError_validator,
    {"auth": "user", "host": "content", "style": "upload"},
)
upload_session_append = bb.Route(
    "upload_session/append",
    1,
    True,
    UploadSessionCursor_validator,
    bv.Void(),
    UploadSessionAppendError_validator,
    {"auth": "user", "host": "content", "style": "upload"},
)
upload_session_append_v2 = bb.Route(
    "upload_session/append",
    2,
    False,
    UploadSessionAppendArg_validator,
    bv.Void(),
    UploadSessionAppendError_validator,
    {"auth": "user", "host": "content", "style": "upload"},
)
upload_session_append_batch = bb.Route(
    "upload_session/append_batch",
    1,
    False,
    UploadSessionAppendBatchArg_validator,
    UploadSessionAppendBatchResult_validator,
    UploadSessionAppendBatchError_validator,
    {"auth": "user", "host": "content", "style": "upload"},
)
upload_session_finish = bb.Route(
    "upload_session/finish",
    1,
    False,
    UploadSessionFinishArg_validator,
    FileMetadata_validator,
    UploadSessionFinishError_validator,
    {"auth": "user", "host": "content", "style": "upload"},
)
upload_session_finish_batch = bb.Route(
    "upload_session/finish_batch",
    1,
    True,
    UploadSessionFinishBatchArg_validator,
    UploadSessionFinishBatchLaunch_validator,
    bv.Void(),
    {"auth": "user", "host": "api", "style": "rpc"},
)
upload_session_finish_batch_v2 = bb.Route(
    "upload_session/finish_batch",
    2,
    False,
    UploadSessionFinishBatchArg_validator,
    UploadSessionFinishBatchResult_validator,
    bv.Void(),
    {"auth": "user", "host": "api", "style": "rpc"},
)
upload_session_finish_batch_check = bb.Route(
    "upload_session/finish_batch/check",
    1,
    False,
    async_.PollArg_validator,
    UploadSessionFinishBatchJobStatus_validator,
    async_.PollError_validator,
    {"auth": "user", "host": "api", "style": "rpc"},
)
upload_session_start = bb.Route(
    "upload_session/start",
    1,
    False,
    UploadSessionStartArg_validator,
    UploadSessionStartResult_validator,
    UploadSessionStartError_validator,
    {"auth": "user", "host": "content", "style": "upload"},
)
upload_session_start_batch = bb.Route(
    "upload_session/start_batch",
    1,
    False,
    UploadSessionStartBatchArg_validator,
    UploadSessionStartBatchResult_validator,
    bv.Void(),
    {"auth": "user", "host": "api", "style": "rpc"},
)

ROUTES = {
    "alpha/get_metadata": alpha_get_metadata,
    "alpha/upload": alpha_upload,
    "copy": copy,
    "copy:2": copy_v2,
    "copy_batch": copy_batch,
    "copy_batch:2": copy_batch_v2,
    "copy_batch/check": copy_batch_check,
    "copy_batch/check:2": copy_batch_check_v2,
    "copy_reference/get": copy_reference_get,
    "copy_reference/save": copy_reference_save,
    "create_folder": create_folder,
    "create_folder:2": create_folder_v2,
    "create_folder_batch": create_folder_batch,
    "create_folder_batch/check": create_folder_batch_check,
    "delete": delete,
    "delete:2": delete_v2,
    "delete_batch": delete_batch,
    "delete_batch/check": delete_batch_check,
    "download": download,
    "download_zip": download_zip,
    "export": export,
    "get_file_lock_batch": get_file_lock_batch,
    "get_metadata": get_metadata,
    "get_preview": get_preview,
    "get_temporary_link": get_temporary_link,
    "get_temporary_upload_link": get_temporary_upload_link,
    "get_thumbnail": get_thumbnail,
    "get_thumbnail:2": get_thumbnail_v2,
    "get_thumbnail_batch": get_thumbnail_batch,
    "list_folder": list_folder,
    "list_folder/continue": list_folder_continue,
    "list_folder/get_latest_cursor": list_folder_get_latest_cursor,
    "list_folder/longpoll": list_folder_longpoll,
    "list_revisions": list_revisions,
    "lock_file_batch": lock_file_batch,
    "move": move,
    "move:2": move_v2,
    "move_batch": move_batch,
    "move_batch:2": move_batch_v2,
    "move_batch/check": move_batch_check,
    "move_batch/check:2": move_batch_check_v2,
    "paper/create": paper_create,
    "paper/update": paper_update,
    "permanently_delete": permanently_delete,
    "properties/add": properties_add,
    "properties/overwrite": properties_overwrite,
    "properties/update": properties_update,
    "restore": restore,
    "save_url": save_url,
    "save_url/check_job_status": save_url_check_job_status,
    "search": search,
    "search:2": search_v2,
    "search/continue:2": search_continue_v2,
    "tags/add": tags_add,
    "tags/get": tags_get,
    "tags/remove": tags_remove,
    "unlock_file_batch": unlock_file_batch,
    "upload": upload,
    "upload_session/append": upload_session_append,
    "upload_session/append:2": upload_session_append_v2,
    "upload_session/append_batch": upload_session_append_batch,
    "upload_session/finish": upload_session_finish,
    "upload_session/finish_batch": upload_session_finish_batch,
    "upload_session/finish_batch:2": upload_session_finish_batch_v2,
    "upload_session/finish_batch/check": upload_session_finish_batch_check,
    "upload_session/start": upload_session_start,
    "upload_session/start_batch": upload_session_start_batch,
}
