# -*- coding: utf-8 -*-
# Auto-generated by Stone, do not modify.
# @generated
# flake8: noqa
# pylint: skip-file
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_


class ApiExifGpsMetadata(bb.Struct):
    """
    GPS coordinates and related tags extracted from image EXIF data. Fields are
    populated on a best-effort basis and may be empty when absent from the
    source file.

    :ivar ApiExifGpsMetadata.latitude:
        Latitude / longitude in decimal degrees (positive = N/E, negative =
        S/W).
    :ivar ApiExifGpsMetadata.altitude:
        Altitude in meters, as reported by the source (string to preserve the
        original representation, which may include a reference direction).
    :ivar ApiExifGpsMetadata.timestamp:
        Timestamp / datestamp of the GPS fix, in the EXIF-provided format.
    """

    __slots__ = [
        "_latitude_value",
        "_longitude_value",
        "_altitude_value",
        "_timestamp_value",
        "_datestamp_value",
    ]

    _has_required_fields = False

    def __init__(
        self,
        latitude=None,
        longitude=None,
        altitude=None,
        timestamp=None,
        datestamp=None,
    ):
        self._latitude_value = bb.NOT_SET
        self._longitude_value = bb.NOT_SET
        self._altitude_value = bb.NOT_SET
        self._timestamp_value = bb.NOT_SET
        self._datestamp_value = bb.NOT_SET
        if latitude is not None:
            self.latitude = latitude
        if longitude is not None:
            self.longitude = longitude
        if altitude is not None:
            self.altitude = altitude
        if timestamp is not None:
            self.timestamp = timestamp
        if datestamp is not None:
            self.datestamp = datestamp

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

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

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

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

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

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


ApiExifGpsMetadata_validator = bv.Struct(ApiExifGpsMetadata)


class ApiExifMetadata(bb.Struct):
    """
    Image EXIF metadata. Mirrors the useful subset of the internal
    `riviera.ExifMetadata` message. Fields are best-effort and may be empty.

    :ivar ApiExifMetadata.date_time_original:
        Capture time in the EXIF-provided format (local time of the camera).
    :ivar ApiExifMetadata.offset_time_original:
        Timezone offset for `date_time_original`, e.g. "+09:00".
    :ivar ApiExifMetadata.orientation:
        EXIF orientation value (1-8). See the EXIF spec; 1 is the normal upright
        orientation.
    :ivar ApiExifMetadata.exposure_time:
        fraction in string form, e.g. "1/250"
    :ivar ApiExifMetadata.focal_length:
        e.g. "26.0 mm"
    """

    __slots__ = [
        "_image_width_value",
        "_image_height_value",
        "_camera_make_value",
        "_camera_model_value",
        "_lens_model_value",
        "_date_time_original_value",
        "_offset_time_original_value",
        "_orientation_value",
        "_exposure_time_value",
        "_aperture_value_value",
        "_iso_speed_value",
        "_focal_length_value",
        "_megapixels_value",
        "_artist_value",
        "_copyright_value",
        "_gps_metadata_value",
    ]

    _has_required_fields = False

    def __init__(
        self,
        image_width=None,
        image_height=None,
        camera_make=None,
        camera_model=None,
        lens_model=None,
        date_time_original=None,
        offset_time_original=None,
        orientation=None,
        exposure_time=None,
        aperture_value=None,
        iso_speed=None,
        focal_length=None,
        megapixels=None,
        artist=None,
        copyright=None,
        gps_metadata=None,
    ):
        self._image_width_value = bb.NOT_SET
        self._image_height_value = bb.NOT_SET
        self._camera_make_value = bb.NOT_SET
        self._camera_model_value = bb.NOT_SET
        self._lens_model_value = bb.NOT_SET
        self._date_time_original_value = bb.NOT_SET
        self._offset_time_original_value = bb.NOT_SET
        self._orientation_value = bb.NOT_SET
        self._exposure_time_value = bb.NOT_SET
        self._aperture_value_value = bb.NOT_SET
        self._iso_speed_value = bb.NOT_SET
        self._focal_length_value = bb.NOT_SET
        self._megapixels_value = bb.NOT_SET
        self._artist_value = bb.NOT_SET
        self._copyright_value = bb.NOT_SET
        self._gps_metadata_value = bb.NOT_SET
        if image_width is not None:
            self.image_width = image_width
        if image_height is not None:
            self.image_height = image_height
        if camera_make is not None:
            self.camera_make = camera_make
        if camera_model is not None:
            self.camera_model = camera_model
        if lens_model is not None:
            self.lens_model = lens_model
        if date_time_original is not None:
            self.date_time_original = date_time_original
        if offset_time_original is not None:
            self.offset_time_original = offset_time_original
        if orientation is not None:
            self.orientation = orientation
        if exposure_time is not None:
            self.exposure_time = exposure_time
        if aperture_value is not None:
            self.aperture_value = aperture_value
        if iso_speed is not None:
            self.iso_speed = iso_speed
        if focal_length is not None:
            self.focal_length = focal_length
        if megapixels is not None:
            self.megapixels = megapixels
        if artist is not None:
            self.artist = artist
        if copyright is not None:
            self.copyright = copyright
        if gps_metadata is not None:
            self.gps_metadata = gps_metadata

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


ApiExifMetadata_validator = bv.Struct(ApiExifMetadata)


class ApiMediaMetadata(bb.Struct):
    """
    Audio/video container and per-stream metadata. Mirrors the useful subset of
    the internal `riviera.MediaMetadata` message.

    :ivar ApiMediaMetadata.creation_time:
        Container-level creation time, when present.
    """

    __slots__ = [
        "_bitrate_bps_value",
        "_duration_s_value",
        "_creation_time_value",
        "_streams_value",
    ]

    _has_required_fields = False

    def __init__(self, bitrate_bps=None, duration_s=None, creation_time=None, streams=None):
        self._bitrate_bps_value = bb.NOT_SET
        self._duration_s_value = bb.NOT_SET
        self._creation_time_value = bb.NOT_SET
        self._streams_value = bb.NOT_SET
        if bitrate_bps is not None:
            self.bitrate_bps = bitrate_bps
        if duration_s is not None:
            self.duration_s = duration_s
        if creation_time is not None:
            self.creation_time = creation_time
        if streams is not None:
            self.streams = streams

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

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

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

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

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


ApiMediaMetadata_validator = bv.Struct(ApiMediaMetadata)


class ApiMediaStream(bb.Struct):
    """
    A single audio or video stream within a media file.

    :ivar ApiMediaStream.codec_type:
        "audio", "video", etc.
    :ivar ApiMediaStream.width:
        Video-specific fields (zero / empty for audio streams).
    :ivar ApiMediaStream.display_aspect_ratio:
        e.g. "16:9"
    :ivar ApiMediaStream.channels:
        Audio-specific fields (zero / empty for video streams).
    :ivar ApiMediaStream.language_iso_639:
        ISO 639 language code for the stream, when present.
    """

    __slots__ = [
        "_index_value",
        "_codec_type_value",
        "_codec_name_value",
        "_bitrate_bps_value",
        "_duration_s_value",
        "_width_value",
        "_height_value",
        "_frames_per_second_value",
        "_rotation_value",
        "_display_aspect_ratio_value",
        "_channels_value",
        "_channel_layout_value",
        "_sample_rate_s_value",
        "_language_iso_639_value",
    ]

    _has_required_fields = False

    def __init__(
        self,
        index=None,
        codec_type=None,
        codec_name=None,
        bitrate_bps=None,
        duration_s=None,
        width=None,
        height=None,
        frames_per_second=None,
        rotation=None,
        display_aspect_ratio=None,
        channels=None,
        channel_layout=None,
        sample_rate_s=None,
        language_iso_639=None,
    ):
        self._index_value = bb.NOT_SET
        self._codec_type_value = bb.NOT_SET
        self._codec_name_value = bb.NOT_SET
        self._bitrate_bps_value = bb.NOT_SET
        self._duration_s_value = bb.NOT_SET
        self._width_value = bb.NOT_SET
        self._height_value = bb.NOT_SET
        self._frames_per_second_value = bb.NOT_SET
        self._rotation_value = bb.NOT_SET
        self._display_aspect_ratio_value = bb.NOT_SET
        self._channels_value = bb.NOT_SET
        self._channel_layout_value = bb.NOT_SET
        self._sample_rate_s_value = bb.NOT_SET
        self._language_iso_639_value = bb.NOT_SET
        if index is not None:
            self.index = index
        if codec_type is not None:
            self.codec_type = codec_type
        if codec_name is not None:
            self.codec_name = codec_name
        if bitrate_bps is not None:
            self.bitrate_bps = bitrate_bps
        if duration_s is not None:
            self.duration_s = duration_s
        if width is not None:
            self.width = width
        if height is not None:
            self.height = height
        if frames_per_second is not None:
            self.frames_per_second = frames_per_second
        if rotation is not None:
            self.rotation = rotation
        if display_aspect_ratio is not None:
            self.display_aspect_ratio = display_aspect_ratio
        if channels is not None:
            self.channels = channels
        if channel_layout is not None:
            self.channel_layout = channel_layout
        if sample_rate_s is not None:
            self.sample_rate_s = sample_rate_s
        if language_iso_639 is not None:
            self.language_iso_639 = language_iso_639

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


ApiMediaStream_validator = bv.Struct(ApiMediaStream)


class ApiOfficeMetadata(bb.Struct):
    """
    MS Office document metadata. Mirrors the internal `riviera.OfficeMetadata`
    message. Some fields apply only to specific document types (e.g. `slides`
    for PowerPoint, `words`/`pages` for Word).

    :ivar ApiOfficeMetadata.pages:
        Word only.
    :ivar ApiOfficeMetadata.slides:
        PowerPoint only.
    """

    __slots__ = [
        "_file_type_value",
        "_creator_value",
        "_company_value",
        "_title_value",
        "_subject_value",
        "_keywords_value",
        "_description_value",
        "_total_edit_time_minutes_value",
        "_pages_value",
        "_words_value",
        "_slides_value",
        "_revision_number_value",
    ]

    _has_required_fields = False

    def __init__(
        self,
        file_type=None,
        creator=None,
        company=None,
        title=None,
        subject=None,
        keywords=None,
        description=None,
        total_edit_time_minutes=None,
        pages=None,
        words=None,
        slides=None,
        revision_number=None,
    ):
        self._file_type_value = bb.NOT_SET
        self._creator_value = bb.NOT_SET
        self._company_value = bb.NOT_SET
        self._title_value = bb.NOT_SET
        self._subject_value = bb.NOT_SET
        self._keywords_value = bb.NOT_SET
        self._description_value = bb.NOT_SET
        self._total_edit_time_minutes_value = bb.NOT_SET
        self._pages_value = bb.NOT_SET
        self._words_value = bb.NOT_SET
        self._slides_value = bb.NOT_SET
        self._revision_number_value = bb.NOT_SET
        if file_type is not None:
            self.file_type = file_type
        if creator is not None:
            self.creator = creator
        if company is not None:
            self.company = company
        if title is not None:
            self.title = title
        if subject is not None:
            self.subject = subject
        if keywords is not None:
            self.keywords = keywords
        if description is not None:
            self.description = description
        if total_edit_time_minutes is not None:
            self.total_edit_time_minutes = total_edit_time_minutes
        if pages is not None:
            self.pages = pages
        if words is not None:
            self.words = words
        if slides is not None:
            self.slides = slides
        if revision_number is not None:
            self.revision_number = revision_number

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

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

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

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

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

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

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

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

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

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

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

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

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


ApiOfficeMetadata_validator = bv.Struct(ApiOfficeMetadata)


class ApiPdfMetadata(bb.Struct):
    """
    PDF document metadata.

    :ivar ApiPdfMetadata.width:
        Width / height of the first page, in PDF points.
    """

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

    _has_required_fields = False

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

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

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

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

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


ApiPdfMetadata_validator = bv.Struct(ApiPdfMetadata)


class ApiStructuredTranscript(bb.Struct):
    """
    Structured transcript for APIv2
    """

    __slots__ = [
        "_segments_value",
        "_transcript_locale_value",
    ]

    _has_required_fields = False

    def __init__(self, segments=None, transcript_locale=None):
        self._segments_value = bb.NOT_SET
        self._transcript_locale_value = bb.NOT_SET
        if segments is not None:
            self.segments = segments
        if transcript_locale is not None:
            self.transcript_locale = transcript_locale

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

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

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


ApiStructuredTranscript_validator = bv.Struct(ApiStructuredTranscript)


class ApiTranscriptSegment(bb.Struct):
    """
    Transcript segment for APIv2
    """

    __slots__ = [
        "_text_value",
        "_start_time_value",
        "_end_time_value",
    ]

    _has_required_fields = False

    def __init__(self, text=None, start_time=None, end_time=None):
        self._text_value = bb.NOT_SET
        self._start_time_value = bb.NOT_SET
        self._end_time_value = bb.NOT_SET
        if text is not None:
            self.text = text
        if start_time is not None:
            self.start_time = start_time
        if end_time is not None:
            self.end_time = end_time

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

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

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

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


ApiTranscriptSegment_validator = bv.Struct(ApiTranscriptSegment)


class ContentApiV2Error(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 ContentApiV2Error.not_found_error:
        The referenced file does not exist or is not accessible.
    :ivar ContentApiV2Error.is_a_folder_error:
        The target is a folder, not a file.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    no_audio_error = None
    # Attribute is overwritten below the class definition
    link_download_disabled_error = None
    # Attribute is overwritten below the class definition
    shared_link_password_protected = None
    # Attribute is overwritten below the class definition
    limit_exceeded_error = None
    # Attribute is overwritten below the class definition
    not_found_error = None
    # Attribute is overwritten below the class definition
    is_a_folder_error = None
    # Attribute is overwritten below the class definition
    other = None

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

        :param str val:
        :rtype: ContentApiV2Error
        """
        return cls("server_error", val)

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

        :param str val:
        :rtype: ContentApiV2Error
        """
        return cls("user_error", val)

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

        :param MediaDurationError val:
        :rtype: ContentApiV2Error
        """
        return cls("media_duration_error", val)

    def is_server_error(self):
        """
        Check if the union tag is ``server_error``.

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

    def is_user_error(self):
        """
        Check if the union tag is ``user_error``.

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

    def is_media_duration_error(self):
        """
        Check if the union tag is ``media_duration_error``.

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

    def is_no_audio_error(self):
        """
        Check if the union tag is ``no_audio_error``.

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

    def is_link_download_disabled_error(self):
        """
        Check if the union tag is ``link_download_disabled_error``.

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

    def is_shared_link_password_protected(self):
        """
        Check if the union tag is ``shared_link_password_protected``.

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

    def is_limit_exceeded_error(self):
        """
        Check if the union tag is ``limit_exceeded_error``.

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

    def is_not_found_error(self):
        """
        Check if the union tag is ``not_found_error``.

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

    def is_is_a_folder_error(self):
        """
        Check if the union tag is ``is_a_folder_error``.

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

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

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

    def get_server_error(self):
        """
        Only call this if :meth:`is_server_error` is true.

        :rtype: str
        """
        if not self.is_server_error():
            raise AttributeError("tag 'server_error' not set")
        return self._value

    def get_user_error(self):
        """
        Only call this if :meth:`is_user_error` is true.

        :rtype: str
        """
        if not self.is_user_error():
            raise AttributeError("tag 'user_error' not set")
        return self._value

    def get_media_duration_error(self):
        """
        Only call this if :meth:`is_media_duration_error` is true.

        :rtype: MediaDurationError
        """
        if not self.is_media_duration_error():
            raise AttributeError("tag 'media_duration_error' not set")
        return self._value

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


ContentApiV2Error_validator = bv.Union(ContentApiV2Error)


class ErrorCode(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 ErrorCode.bad_request:
        400
    :ivar ErrorCode.api_error:
        409
    :ivar ErrorCode.access_error:
        403
    :ivar ErrorCode.ratelimit_error:
        429
    :ivar ErrorCode.unavailable:
        503
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    unknown_error = None
    # Attribute is overwritten below the class definition
    bad_request = None
    # Attribute is overwritten below the class definition
    api_error = None
    # Attribute is overwritten below the class definition
    access_error = None
    # Attribute is overwritten below the class definition
    ratelimit_error = None
    # Attribute is overwritten below the class definition
    unavailable = None
    # Attribute is overwritten below the class definition
    other = None

    def is_unknown_error(self):
        """
        Check if the union tag is ``unknown_error``.

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

    def is_bad_request(self):
        """
        Check if the union tag is ``bad_request``.

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

    def is_api_error(self):
        """
        Check if the union tag is ``api_error``.

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

    def is_access_error(self):
        """
        Check if the union tag is ``access_error``.

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

    def is_ratelimit_error(self):
        """
        Check if the union tag is ``ratelimit_error``.

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

    def is_unavailable(self):
        """
        Check if the union tag is ``unavailable``.

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

    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(ErrorCode, self)._process_custom_annotations(annotation_type, field_path, processor)


ErrorCode_validator = bv.Union(ErrorCode)


class FileIdOrUrl(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 file_id(cls, val):
        """
        Create an instance of this class set to the ``file_id`` tag with value
        ``val``.

        :param str val:
        :rtype: FileIdOrUrl
        """
        return cls("file_id", val)

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

        :param str val:
        :rtype: FileIdOrUrl
        """
        return cls("url", val)

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

        :param str val:
        :rtype: FileIdOrUrl
        """
        return cls("path", val)

    def is_file_id(self):
        """
        Check if the union tag is ``file_id``.

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

    def is_url(self):
        """
        Check if the union tag is ``url``.

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

    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_file_id(self):
        """
        Only call this if :meth:`is_file_id` is true.

        :rtype: str
        """
        if not self.is_file_id():
            raise AttributeError("tag 'file_id' not set")
        return self._value

    def get_url(self):
        """
        Only call this if :meth:`is_url` is true.

        :rtype: str
        """
        if not self.is_url():
            raise AttributeError("tag 'url' not set")
        return self._value

    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 _process_custom_annotations(self, annotation_type, field_path, processor):
        super(FileIdOrUrl, self)._process_custom_annotations(annotation_type, field_path, processor)


FileIdOrUrl_validator = bv.Union(FileIdOrUrl)


class GetMarkdownArgs(bb.Struct):
    """
    Arguments for the asynchronous `get_markdown_async` route. Exactly one of
    `file_id`, `path`, or `url` must be supplied via `file_id_or_url` to
    identify the document to convert to markdown.

    :ivar GetMarkdownArgs.file_id_or_url:
        Identifier of the document to convert. Callers must set exactly one of
        the oneof variants: - file_id: a Dropbox-issued file id (format:
        "id:<id>") for a file the authenticated user has access to. - path: an
        absolute Dropbox path, e.g. "/folder/report.docx". - url: either a
        Dropbox shared link (www.dropbox.com) or an external HTTPS URL pointing
        to a supported document file. - Dropbox shared links are resolved
        internally using the caller's authenticated identity and the link's
        visibility / download settings. They therefore require an authenticated
        user context (anonymous `url` requests against Dropbox links are
        rejected with an `ACCESS_ERROR`). Links protected by a password are
        rejected with `shared_link_password_protected`; links with downloads
        disabled are rejected with `link_download_disabled_error`. - External
        URLs are fetched over HTTPS through the backend's egress proxy and must
        point at a supported document file extension. The referenced file must
        be a document in a supported format; requests against unsupported
        formats return `unsupported_format_error`.
    :ivar GetMarkdownArgs.enable_ocr:
        Enable OCR for PDF documents. Processing is slower when enabled.
    :ivar GetMarkdownArgs.embed_images:
        When true, embed images as base64 data URIs in the markdown output. This
        can significantly increase output size.
    """

    __slots__ = [
        "_file_id_or_url_value",
        "_enable_ocr_value",
        "_embed_images_value",
    ]

    _has_required_fields = False

    def __init__(self, file_id_or_url=None, enable_ocr=None, embed_images=None):
        self._file_id_or_url_value = bb.NOT_SET
        self._enable_ocr_value = bb.NOT_SET
        self._embed_images_value = bb.NOT_SET
        if file_id_or_url is not None:
            self.file_id_or_url = file_id_or_url
        if enable_ocr is not None:
            self.enable_ocr = enable_ocr
        if embed_images is not None:
            self.embed_images = embed_images

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

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

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

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


GetMarkdownArgs_validator = bv.Struct(GetMarkdownArgs)


class GetMarkdownAsyncCheckResult(bb.Union):
    """
    Result type for EventBus async check

    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
    in_progress = None
    # 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 GetMarkdownResult val:
        :rtype: GetMarkdownAsyncCheckResult
        """
        return cls("complete", val)

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

        :param GetMarkdownAsyncError val:
        :rtype: GetMarkdownAsyncCheckResult
        """
        return cls("failed", val)

    def is_in_progress(self):
        """
        Check if the union tag is ``in_progress``.

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

    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):
        """
        Only call this if :meth:`is_complete` is true.

        :rtype: GetMarkdownResult
        """
        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: GetMarkdownAsyncError
        """
        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(GetMarkdownAsyncCheckResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetMarkdownAsyncCheckResult_validator = bv.Union(GetMarkdownAsyncCheckResult)


class GetMarkdownAsyncError(bb.Struct):
    __slots__ = [
        "_error_code_value",
        "_error_details_value",
    ]

    _has_required_fields = False

    def __init__(self, error_code=None, error_details=None):
        self._error_code_value = bb.NOT_SET
        self._error_details_value = bb.NOT_SET
        if error_code is not None:
            self.error_code = error_code
        if error_details is not None:
            self.error_details = error_details

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

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

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


GetMarkdownAsyncError_validator = bv.Struct(GetMarkdownAsyncError)


class GetMarkdownResult(bb.Struct):
    """
    :ivar GetMarkdownResult.markdown:
        The converted markdown content
    """

    __slots__ = [
        "_markdown_value",
    ]

    _has_required_fields = False

    def __init__(self, markdown=None):
        self._markdown_value = bb.NOT_SET
        if markdown is not None:
            self.markdown = markdown

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

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


GetMarkdownResult_validator = bv.Struct(GetMarkdownResult)


class GetMetadataArgs(bb.Struct):
    """
    Arguments for the asynchronous `get_metadata_async` route. Exactly one of
    `file_id`, `path`, or `url` must be supplied via `file_id_or_url` to
    identify the file whose metadata should be extracted.

    :ivar GetMetadataArgs.file_id_or_url:
        Identifier of the file to extract metadata from. Callers must set
        exactly one of the oneof variants: - file_id: a Dropbox-issued file id
        (format: "id:<id>") for a file the authenticated user has access to. -
        path: an absolute Dropbox path, e.g. "/folder/photo.jpg". - url: either
        a Dropbox shared link (www.dropbox.com) or an external HTTPS URL
        pointing to a supported file. - Dropbox shared links are resolved
        internally using the caller's authenticated identity and the link's
        visibility / download settings. They therefore require an authenticated
        user context (anonymous `url` requests against Dropbox links are
        rejected with an `ACCESS_ERROR`). Links protected by a password are
        rejected with `shared_link_password_protected`; links with downloads
        disabled are rejected with `link_download_disabled_error`. - External
        URLs are fetched over HTTPS through the backend's egress proxy and must
        point at a supported file extension. The kind of metadata returned is
        determined by the file type: image files return EXIF metadata,
        audio/video files return media metadata, PDFs return PDF metadata, and
        MS Office documents (docx, pptx, xlsx) return Office metadata. Requests
        against unsupported formats return `unsupported_format_error`.
    """

    __slots__ = [
        "_file_id_or_url_value",
    ]

    _has_required_fields = False

    def __init__(self, file_id_or_url=None):
        self._file_id_or_url_value = bb.NOT_SET
        if file_id_or_url is not None:
            self.file_id_or_url = file_id_or_url

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

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


GetMetadataArgs_validator = bv.Struct(GetMetadataArgs)


class GetMetadataAsyncCheckResult(bb.Union):
    """
    Result type for EventBus async check - must end in "CheckResult"

    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
    in_progress = None
    # 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 GetMetadataResult val:
        :rtype: GetMetadataAsyncCheckResult
        """
        return cls("complete", val)

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

        :param GetMetadataAsyncError val:
        :rtype: GetMetadataAsyncCheckResult
        """
        return cls("failed", val)

    def is_in_progress(self):
        """
        Check if the union tag is ``in_progress``.

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

    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):
        """
        Only call this if :meth:`is_complete` is true.

        :rtype: GetMetadataResult
        """
        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: GetMetadataAsyncError
        """
        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(GetMetadataAsyncCheckResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetMetadataAsyncCheckResult_validator = bv.Union(GetMetadataAsyncCheckResult)


class GetMetadataAsyncError(bb.Struct):
    __slots__ = [
        "_error_code_value",
        "_error_details_value",
    ]

    _has_required_fields = False

    def __init__(self, error_code=None, error_details=None):
        self._error_code_value = bb.NOT_SET
        self._error_details_value = bb.NOT_SET
        if error_code is not None:
            self.error_code = error_code
        if error_details is not None:
            self.error_details = error_details

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

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

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


GetMetadataAsyncError_validator = bv.Struct(GetMetadataAsyncError)


class GetMetadataResult(bb.Struct):
    """
    :ivar GetMetadataResult.metadata_type:
        The kind of metadata that was extracted for the requested file. Callers
        should read the matching field of the `metadata` oneof.
    """

    __slots__ = [
        "_metadata_type_value",
        "_metadata_value",
    ]

    _has_required_fields = False

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

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

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

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


GetMetadataResult_validator = bv.Struct(GetMetadataResult)


class GetTranscriptArgs(bb.Struct):
    """
    Arguments for the asynchronous `get_transcript_async` route. Exactly one of
    `file_id`, `path`, or `url` must be supplied via `file_id_or_url` to
    identify the audio or video asset to transcribe.

    :ivar GetTranscriptArgs.file_id_or_url:
        Identifier of the media asset to transcribe. Callers must set exactly
        one of the oneof variants: - file_id: a Dropbox-issued file id (format:
        "id:<id>") for a file the authenticated user has access to. - path: an
        absolute Dropbox path, e.g. "/folder/recording.mp4". - url: either a
        Dropbox shared link (www.dropbox.com) or an external HTTPS URL pointing
        to a supported audio/video file. - Dropbox shared links are resolved
        internally using the caller's authenticated identity and the link's
        visibility / download settings. They therefore require an authenticated
        user context (anonymous `url` requests against Dropbox links are
        rejected with an `ACCESS_ERROR`). Links protected by a password are
        rejected with `shared_link_password_protected`; links with downloads
        disabled are rejected with `link_download_disabled_error`. - External
        URLs are fetched over HTTPS through the backend's egress proxy and must
        point at a supported audio/video file extension. The referenced asset
        must be an audio or video file in a supported format; requests against
        files with no audio track return a `no_audio_error`.
    :ivar GetTranscriptArgs.timestamp_level:
        Granularity of the time offsets returned for each transcript segment.
        Defaults to `SENTENCE. - SENTENCE: one segment per spoken sentence
        (recommended). - WORD: one segment per word, useful for fine-grained
        alignment such as captioning or highlight-as-you-listen experiences.
    :ivar GetTranscriptArgs.included_special_words:
        Comma-delimited list of non-lexical filler words to preserve in the
        transcript output, e.g. `"uh, ah, uhm"`. By default these fillers are
        stripped. Unrecognized tokens are ignored. Leave empty to use the
        default filtering behavior.
    :ivar GetTranscriptArgs.audio_language:
        Optional ISO 639-1 two-letter language code hinting the spoken language
        of the source audio (e.g. "en", "ja"). When empty, the service
        auto-detects the language; supplying a hint improves accuracy and
        latency for short or ambiguous clips. Unsupported languages fall back to
        auto-detection.
    """

    __slots__ = [
        "_file_id_or_url_value",
        "_timestamp_level_value",
        "_included_special_words_value",
        "_audio_language_value",
    ]

    _has_required_fields = False

    def __init__(
        self,
        file_id_or_url=None,
        timestamp_level=None,
        included_special_words=None,
        audio_language=None,
    ):
        self._file_id_or_url_value = bb.NOT_SET
        self._timestamp_level_value = bb.NOT_SET
        self._included_special_words_value = bb.NOT_SET
        self._audio_language_value = bb.NOT_SET
        if file_id_or_url is not None:
            self.file_id_or_url = file_id_or_url
        if timestamp_level is not None:
            self.timestamp_level = timestamp_level
        if included_special_words is not None:
            self.included_special_words = included_special_words
        if audio_language is not None:
            self.audio_language = audio_language

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

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

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

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

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


GetTranscriptArgs_validator = bv.Struct(GetTranscriptArgs)


class GetTranscriptAsyncCheckResult(bb.Union):
    """
    Result type for EventBus async check - must end in "CheckResult"

    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
    in_progress = None
    # 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 GetTranscriptResult val:
        :rtype: GetTranscriptAsyncCheckResult
        """
        return cls("complete", val)

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

        :param GetTranscriptAsyncError val:
        :rtype: GetTranscriptAsyncCheckResult
        """
        return cls("failed", val)

    def is_in_progress(self):
        """
        Check if the union tag is ``in_progress``.

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

    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):
        """
        Only call this if :meth:`is_complete` is true.

        :rtype: GetTranscriptResult
        """
        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: GetTranscriptAsyncError
        """
        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(GetTranscriptAsyncCheckResult, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


GetTranscriptAsyncCheckResult_validator = bv.Union(GetTranscriptAsyncCheckResult)


class GetTranscriptAsyncError(bb.Struct):
    __slots__ = [
        "_error_code_value",
        "_error_details_value",
    ]

    _has_required_fields = False

    def __init__(self, error_code=None, error_details=None):
        self._error_code_value = bb.NOT_SET
        self._error_details_value = bb.NOT_SET
        if error_code is not None:
            self.error_code = error_code
        if error_details is not None:
            self.error_details = error_details

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

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

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


GetTranscriptAsyncError_validator = bv.Struct(GetTranscriptAsyncError)


class GetTranscriptResult(bb.Struct):
    """
    :ivar GetTranscriptResult.structured_transcript:
        The structured transcript produced for the requested media asset, with
        per-segment text, start/end offsets (in seconds from the beginning of
        the media), and the detected or caller-supplied locale.
    """

    __slots__ = [
        "_structured_transcript_value",
    ]

    _has_required_fields = False

    def __init__(self, structured_transcript=None):
        self._structured_transcript_value = bb.NOT_SET
        if structured_transcript is not None:
            self.structured_transcript = structured_transcript

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

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


GetTranscriptResult_validator = bv.Struct(GetTranscriptResult)


class MarkdownConversionApiV2Error(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 MarkdownConversionApiV2Error.not_found_error:
        The referenced file does not exist or is not accessible.
    :ivar MarkdownConversionApiV2Error.is_a_folder_error:
        The target is a folder, not a file.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    unsupported_format_error = None
    # Attribute is overwritten below the class definition
    link_download_disabled_error = None
    # Attribute is overwritten below the class definition
    shared_link_password_protected = None
    # Attribute is overwritten below the class definition
    limit_exceeded_error = None
    # Attribute is overwritten below the class definition
    conversion_failure_error = None
    # Attribute is overwritten below the class definition
    not_found_error = None
    # Attribute is overwritten below the class definition
    is_a_folder_error = None
    # Attribute is overwritten below the class definition
    other = None

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

        :param str val:
        :rtype: MarkdownConversionApiV2Error
        """
        return cls("server_error", val)

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

        :param str val:
        :rtype: MarkdownConversionApiV2Error
        """
        return cls("user_error", val)

    def is_server_error(self):
        """
        Check if the union tag is ``server_error``.

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

    def is_user_error(self):
        """
        Check if the union tag is ``user_error``.

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

    def is_unsupported_format_error(self):
        """
        Check if the union tag is ``unsupported_format_error``.

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

    def is_link_download_disabled_error(self):
        """
        Check if the union tag is ``link_download_disabled_error``.

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

    def is_shared_link_password_protected(self):
        """
        Check if the union tag is ``shared_link_password_protected``.

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

    def is_limit_exceeded_error(self):
        """
        Check if the union tag is ``limit_exceeded_error``.

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

    def is_conversion_failure_error(self):
        """
        Check if the union tag is ``conversion_failure_error``.

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

    def is_not_found_error(self):
        """
        Check if the union tag is ``not_found_error``.

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

    def is_is_a_folder_error(self):
        """
        Check if the union tag is ``is_a_folder_error``.

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

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

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

    def get_server_error(self):
        """
        Only call this if :meth:`is_server_error` is true.

        :rtype: str
        """
        if not self.is_server_error():
            raise AttributeError("tag 'server_error' not set")
        return self._value

    def get_user_error(self):
        """
        Only call this if :meth:`is_user_error` is true.

        :rtype: str
        """
        if not self.is_user_error():
            raise AttributeError("tag 'user_error' not set")
        return self._value

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


MarkdownConversionApiV2Error_validator = bv.Union(MarkdownConversionApiV2Error)


class MediaDurationError(bb.Struct):
    __slots__ = [
        "_limit_value",
    ]

    _has_required_fields = False

    def __init__(self, limit=None):
        self._limit_value = bb.NOT_SET
        if limit is not None:
            self.limit = limit

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

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


MediaDurationError_validator = bv.Struct(MediaDurationError)


class MetadataExtractionApiV2Error(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 MetadataExtractionApiV2Error.not_found_error:
        The referenced file does not exist or is not accessible.
    :ivar MetadataExtractionApiV2Error.is_a_folder_error:
        The target is a folder, not a file.
    """

    _catch_all = "other"
    # Attribute is overwritten below the class definition
    unsupported_format_error = None
    # Attribute is overwritten below the class definition
    link_download_disabled_error = None
    # Attribute is overwritten below the class definition
    shared_link_password_protected = None
    # Attribute is overwritten below the class definition
    limit_exceeded_error = None
    # Attribute is overwritten below the class definition
    conversion_failure_error = None
    # Attribute is overwritten below the class definition
    not_found_error = None
    # Attribute is overwritten below the class definition
    is_a_folder_error = None
    # Attribute is overwritten below the class definition
    other = None

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

        :param str val:
        :rtype: MetadataExtractionApiV2Error
        """
        return cls("server_error", val)

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

        :param str val:
        :rtype: MetadataExtractionApiV2Error
        """
        return cls("user_error", val)

    def is_server_error(self):
        """
        Check if the union tag is ``server_error``.

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

    def is_user_error(self):
        """
        Check if the union tag is ``user_error``.

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

    def is_unsupported_format_error(self):
        """
        Check if the union tag is ``unsupported_format_error``.

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

    def is_link_download_disabled_error(self):
        """
        Check if the union tag is ``link_download_disabled_error``.

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

    def is_shared_link_password_protected(self):
        """
        Check if the union tag is ``shared_link_password_protected``.

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

    def is_limit_exceeded_error(self):
        """
        Check if the union tag is ``limit_exceeded_error``.

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

    def is_conversion_failure_error(self):
        """
        Check if the union tag is ``conversion_failure_error``.

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

    def is_not_found_error(self):
        """
        Check if the union tag is ``not_found_error``.

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

    def is_is_a_folder_error(self):
        """
        Check if the union tag is ``is_a_folder_error``.

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

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

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

    def get_server_error(self):
        """
        Only call this if :meth:`is_server_error` is true.

        :rtype: str
        """
        if not self.is_server_error():
            raise AttributeError("tag 'server_error' not set")
        return self._value

    def get_user_error(self):
        """
        Only call this if :meth:`is_user_error` is true.

        :rtype: str
        """
        if not self.is_user_error():
            raise AttributeError("tag 'user_error' not set")
        return self._value

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


MetadataExtractionApiV2Error_validator = bv.Union(MetadataExtractionApiV2Error)


class MetadataType(bb.Union):
    """
    Which metadata variant is populated in a `GetMetadataResult`, derived from
    the file type.

    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
    metadata_type_unknown = None
    # Attribute is overwritten below the class definition
    metadata_type_exif = None
    # Attribute is overwritten below the class definition
    metadata_type_media = None
    # Attribute is overwritten below the class definition
    metadata_type_pdf = None
    # Attribute is overwritten below the class definition
    metadata_type_office = None
    # Attribute is overwritten below the class definition
    other = None

    def is_metadata_type_unknown(self):
        """
        Check if the union tag is ``metadata_type_unknown``.

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

    def is_metadata_type_exif(self):
        """
        Check if the union tag is ``metadata_type_exif``.

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

    def is_metadata_type_media(self):
        """
        Check if the union tag is ``metadata_type_media``.

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

    def is_metadata_type_pdf(self):
        """
        Check if the union tag is ``metadata_type_pdf``.

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

    def is_metadata_type_office(self):
        """
        Check if the union tag is ``metadata_type_office``.

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

    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(MetadataType, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


MetadataType_validator = bv.Union(MetadataType)


class OfficeFileType(bb.Union):
    """
    The kind of MS Office document that produced an `ApiOfficeMetadata` result.

    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
    office_filetype_unknown = None
    # Attribute is overwritten below the class definition
    office_filetype_word = None
    # Attribute is overwritten below the class definition
    office_filetype_powerpoint = None
    # Attribute is overwritten below the class definition
    office_filetype_excel = None
    # Attribute is overwritten below the class definition
    other = None

    def is_office_filetype_unknown(self):
        """
        Check if the union tag is ``office_filetype_unknown``.

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

    def is_office_filetype_word(self):
        """
        Check if the union tag is ``office_filetype_word``.

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

    def is_office_filetype_powerpoint(self):
        """
        Check if the union tag is ``office_filetype_powerpoint``.

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

    def is_office_filetype_excel(self):
        """
        Check if the union tag is ``office_filetype_excel``.

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

    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(OfficeFileType, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


OfficeFileType_validator = bv.Union(OfficeFileType)


class TimestampLevel(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
    unknown = None
    # Attribute is overwritten below the class definition
    sentence = None
    # Attribute is overwritten below the class definition
    word = None
    # Attribute is overwritten below the class definition
    other = None

    def is_unknown(self):
        """
        Check if the union tag is ``unknown``.

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

    def is_sentence(self):
        """
        Check if the union tag is ``sentence``.

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

    def is_word(self):
        """
        Check if the union tag is ``word``.

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

    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(TimestampLevel, self)._process_custom_annotations(
            annotation_type, field_path, processor
        )


TimestampLevel_validator = bv.Union(TimestampLevel)


class MetadataUnion(bb.Union):
    """
    Exactly one variant is populated, corresponding to `metadata_type`.

    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 exif(cls, val):
        """
        Create an instance of this class set to the ``exif`` tag with value
        ``val``.

        :param ApiExifMetadata val:
        :rtype: MetadataUnion
        """
        return cls("exif", val)

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

        :param ApiMediaMetadata val:
        :rtype: MetadataUnion
        """
        return cls("media", val)

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

        :param ApiPdfMetadata val:
        :rtype: MetadataUnion
        """
        return cls("pdf", val)

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

        :param ApiOfficeMetadata val:
        :rtype: MetadataUnion
        """
        return cls("office", val)

    def is_exif(self):
        """
        Check if the union tag is ``exif``.

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

    def is_media(self):
        """
        Check if the union tag is ``media``.

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

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

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

    def is_office(self):
        """
        Check if the union tag is ``office``.

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

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

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

    def get_exif(self):
        """
        Only call this if :meth:`is_exif` is true.

        :rtype: ApiExifMetadata
        """
        if not self.is_exif():
            raise AttributeError("tag 'exif' not set")
        return self._value

    def get_media(self):
        """
        Only call this if :meth:`is_media` is true.

        :rtype: ApiMediaMetadata
        """
        if not self.is_media():
            raise AttributeError("tag 'media' not set")
        return self._value

    def get_pdf(self):
        """
        Only call this if :meth:`is_pdf` is true.

        :rtype: ApiPdfMetadata
        """
        if not self.is_pdf():
            raise AttributeError("tag 'pdf' not set")
        return self._value

    def get_office(self):
        """
        Only call this if :meth:`is_office` is true.

        :rtype: ApiOfficeMetadata
        """
        if not self.is_office():
            raise AttributeError("tag 'office' not set")
        return self._value

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


MetadataUnion_validator = bv.Union(MetadataUnion)

ApiExifGpsMetadata.latitude.validator = bv.Float32()
ApiExifGpsMetadata.longitude.validator = bv.Float32()
ApiExifGpsMetadata.altitude.validator = bv.String()
ApiExifGpsMetadata.timestamp.validator = bv.String()
ApiExifGpsMetadata.datestamp.validator = bv.String()
ApiExifGpsMetadata._all_field_names_ = set(
    [
        "latitude",
        "longitude",
        "altitude",
        "timestamp",
        "datestamp",
    ]
)
ApiExifGpsMetadata._all_fields_ = [
    ("latitude", ApiExifGpsMetadata.latitude.validator),
    ("longitude", ApiExifGpsMetadata.longitude.validator),
    ("altitude", ApiExifGpsMetadata.altitude.validator),
    ("timestamp", ApiExifGpsMetadata.timestamp.validator),
    ("datestamp", ApiExifGpsMetadata.datestamp.validator),
]

ApiExifMetadata.image_width.validator = bv.UInt32()
ApiExifMetadata.image_height.validator = bv.UInt32()
ApiExifMetadata.camera_make.validator = bv.String()
ApiExifMetadata.camera_model.validator = bv.String()
ApiExifMetadata.lens_model.validator = bv.String()
ApiExifMetadata.date_time_original.validator = bv.String()
ApiExifMetadata.offset_time_original.validator = bv.String()
ApiExifMetadata.orientation.validator = bv.UInt32()
ApiExifMetadata.exposure_time.validator = bv.String()
ApiExifMetadata.aperture_value.validator = bv.Float64()
ApiExifMetadata.iso_speed.validator = bv.UInt32()
ApiExifMetadata.focal_length.validator = bv.String()
ApiExifMetadata.megapixels.validator = bv.Float64()
ApiExifMetadata.artist.validator = bv.String()
ApiExifMetadata.copyright.validator = bv.String()
ApiExifMetadata.gps_metadata.validator = bv.Nullable(ApiExifGpsMetadata_validator)
ApiExifMetadata._all_field_names_ = set(
    [
        "image_width",
        "image_height",
        "camera_make",
        "camera_model",
        "lens_model",
        "date_time_original",
        "offset_time_original",
        "orientation",
        "exposure_time",
        "aperture_value",
        "iso_speed",
        "focal_length",
        "megapixels",
        "artist",
        "copyright",
        "gps_metadata",
    ]
)
ApiExifMetadata._all_fields_ = [
    ("image_width", ApiExifMetadata.image_width.validator),
    ("image_height", ApiExifMetadata.image_height.validator),
    ("camera_make", ApiExifMetadata.camera_make.validator),
    ("camera_model", ApiExifMetadata.camera_model.validator),
    ("lens_model", ApiExifMetadata.lens_model.validator),
    ("date_time_original", ApiExifMetadata.date_time_original.validator),
    ("offset_time_original", ApiExifMetadata.offset_time_original.validator),
    ("orientation", ApiExifMetadata.orientation.validator),
    ("exposure_time", ApiExifMetadata.exposure_time.validator),
    ("aperture_value", ApiExifMetadata.aperture_value.validator),
    ("iso_speed", ApiExifMetadata.iso_speed.validator),
    ("focal_length", ApiExifMetadata.focal_length.validator),
    ("megapixels", ApiExifMetadata.megapixels.validator),
    ("artist", ApiExifMetadata.artist.validator),
    ("copyright", ApiExifMetadata.copyright.validator),
    ("gps_metadata", ApiExifMetadata.gps_metadata.validator),
]

ApiMediaMetadata.bitrate_bps.validator = bv.UInt64()
ApiMediaMetadata.duration_s.validator = bv.Float64()
ApiMediaMetadata.creation_time.validator = bv.String()
ApiMediaMetadata.streams.validator = bv.Nullable(bv.List(ApiMediaStream_validator))
ApiMediaMetadata._all_field_names_ = set(
    [
        "bitrate_bps",
        "duration_s",
        "creation_time",
        "streams",
    ]
)
ApiMediaMetadata._all_fields_ = [
    ("bitrate_bps", ApiMediaMetadata.bitrate_bps.validator),
    ("duration_s", ApiMediaMetadata.duration_s.validator),
    ("creation_time", ApiMediaMetadata.creation_time.validator),
    ("streams", ApiMediaMetadata.streams.validator),
]

ApiMediaStream.index.validator = bv.UInt32()
ApiMediaStream.codec_type.validator = bv.String()
ApiMediaStream.codec_name.validator = bv.String()
ApiMediaStream.bitrate_bps.validator = bv.UInt64()
ApiMediaStream.duration_s.validator = bv.Float64()
ApiMediaStream.width.validator = bv.UInt32()
ApiMediaStream.height.validator = bv.UInt32()
ApiMediaStream.frames_per_second.validator = bv.Float64()
ApiMediaStream.rotation.validator = bv.Int32()
ApiMediaStream.display_aspect_ratio.validator = bv.String()
ApiMediaStream.channels.validator = bv.UInt32()
ApiMediaStream.channel_layout.validator = bv.String()
ApiMediaStream.sample_rate_s.validator = bv.UInt64()
ApiMediaStream.language_iso_639.validator = bv.String()
ApiMediaStream._all_field_names_ = set(
    [
        "index",
        "codec_type",
        "codec_name",
        "bitrate_bps",
        "duration_s",
        "width",
        "height",
        "frames_per_second",
        "rotation",
        "display_aspect_ratio",
        "channels",
        "channel_layout",
        "sample_rate_s",
        "language_iso_639",
    ]
)
ApiMediaStream._all_fields_ = [
    ("index", ApiMediaStream.index.validator),
    ("codec_type", ApiMediaStream.codec_type.validator),
    ("codec_name", ApiMediaStream.codec_name.validator),
    ("bitrate_bps", ApiMediaStream.bitrate_bps.validator),
    ("duration_s", ApiMediaStream.duration_s.validator),
    ("width", ApiMediaStream.width.validator),
    ("height", ApiMediaStream.height.validator),
    ("frames_per_second", ApiMediaStream.frames_per_second.validator),
    ("rotation", ApiMediaStream.rotation.validator),
    ("display_aspect_ratio", ApiMediaStream.display_aspect_ratio.validator),
    ("channels", ApiMediaStream.channels.validator),
    ("channel_layout", ApiMediaStream.channel_layout.validator),
    ("sample_rate_s", ApiMediaStream.sample_rate_s.validator),
    ("language_iso_639", ApiMediaStream.language_iso_639.validator),
]

ApiOfficeMetadata.file_type.validator = OfficeFileType_validator
ApiOfficeMetadata.creator.validator = bv.String()
ApiOfficeMetadata.company.validator = bv.String()
ApiOfficeMetadata.title.validator = bv.String()
ApiOfficeMetadata.subject.validator = bv.String()
ApiOfficeMetadata.keywords.validator = bv.String()
ApiOfficeMetadata.description.validator = bv.String()
ApiOfficeMetadata.total_edit_time_minutes.validator = bv.UInt32()
ApiOfficeMetadata.pages.validator = bv.UInt32()
ApiOfficeMetadata.words.validator = bv.UInt32()
ApiOfficeMetadata.slides.validator = bv.UInt32()
ApiOfficeMetadata.revision_number.validator = bv.String()
ApiOfficeMetadata._all_field_names_ = set(
    [
        "file_type",
        "creator",
        "company",
        "title",
        "subject",
        "keywords",
        "description",
        "total_edit_time_minutes",
        "pages",
        "words",
        "slides",
        "revision_number",
    ]
)
ApiOfficeMetadata._all_fields_ = [
    ("file_type", ApiOfficeMetadata.file_type.validator),
    ("creator", ApiOfficeMetadata.creator.validator),
    ("company", ApiOfficeMetadata.company.validator),
    ("title", ApiOfficeMetadata.title.validator),
    ("subject", ApiOfficeMetadata.subject.validator),
    ("keywords", ApiOfficeMetadata.keywords.validator),
    ("description", ApiOfficeMetadata.description.validator),
    ("total_edit_time_minutes", ApiOfficeMetadata.total_edit_time_minutes.validator),
    ("pages", ApiOfficeMetadata.pages.validator),
    ("words", ApiOfficeMetadata.words.validator),
    ("slides", ApiOfficeMetadata.slides.validator),
    ("revision_number", ApiOfficeMetadata.revision_number.validator),
]

ApiPdfMetadata.pages.validator = bv.UInt32()
ApiPdfMetadata.width.validator = bv.UInt32()
ApiPdfMetadata.height.validator = bv.UInt32()
ApiPdfMetadata._all_field_names_ = set(
    [
        "pages",
        "width",
        "height",
    ]
)
ApiPdfMetadata._all_fields_ = [
    ("pages", ApiPdfMetadata.pages.validator),
    ("width", ApiPdfMetadata.width.validator),
    ("height", ApiPdfMetadata.height.validator),
]

ApiStructuredTranscript.segments.validator = bv.Nullable(bv.List(ApiTranscriptSegment_validator))
ApiStructuredTranscript.transcript_locale.validator = bv.String()
ApiStructuredTranscript._all_field_names_ = set(
    [
        "segments",
        "transcript_locale",
    ]
)
ApiStructuredTranscript._all_fields_ = [
    ("segments", ApiStructuredTranscript.segments.validator),
    ("transcript_locale", ApiStructuredTranscript.transcript_locale.validator),
]

ApiTranscriptSegment.text.validator = bv.String()
ApiTranscriptSegment.start_time.validator = bv.Float64()
ApiTranscriptSegment.end_time.validator = bv.Float64()
ApiTranscriptSegment._all_field_names_ = set(
    [
        "text",
        "start_time",
        "end_time",
    ]
)
ApiTranscriptSegment._all_fields_ = [
    ("text", ApiTranscriptSegment.text.validator),
    ("start_time", ApiTranscriptSegment.start_time.validator),
    ("end_time", ApiTranscriptSegment.end_time.validator),
]

ContentApiV2Error._server_error_validator = bv.String()
ContentApiV2Error._user_error_validator = bv.String()
ContentApiV2Error._media_duration_error_validator = MediaDurationError_validator
ContentApiV2Error._no_audio_error_validator = bv.Void()
ContentApiV2Error._link_download_disabled_error_validator = bv.Void()
ContentApiV2Error._shared_link_password_protected_validator = bv.Void()
ContentApiV2Error._limit_exceeded_error_validator = bv.Void()
ContentApiV2Error._not_found_error_validator = bv.Void()
ContentApiV2Error._is_a_folder_error_validator = bv.Void()
ContentApiV2Error._other_validator = bv.Void()
ContentApiV2Error._tagmap = {
    "server_error": ContentApiV2Error._server_error_validator,
    "user_error": ContentApiV2Error._user_error_validator,
    "media_duration_error": ContentApiV2Error._media_duration_error_validator,
    "no_audio_error": ContentApiV2Error._no_audio_error_validator,
    "link_download_disabled_error": ContentApiV2Error._link_download_disabled_error_validator,
    "shared_link_password_protected": ContentApiV2Error._shared_link_password_protected_validator,
    "limit_exceeded_error": ContentApiV2Error._limit_exceeded_error_validator,
    "not_found_error": ContentApiV2Error._not_found_error_validator,
    "is_a_folder_error": ContentApiV2Error._is_a_folder_error_validator,
    "other": ContentApiV2Error._other_validator,
}

ContentApiV2Error.no_audio_error = ContentApiV2Error("no_audio_error")
ContentApiV2Error.link_download_disabled_error = ContentApiV2Error("link_download_disabled_error")
ContentApiV2Error.shared_link_password_protected = ContentApiV2Error(
    "shared_link_password_protected"
)
ContentApiV2Error.limit_exceeded_error = ContentApiV2Error("limit_exceeded_error")
ContentApiV2Error.not_found_error = ContentApiV2Error("not_found_error")
ContentApiV2Error.is_a_folder_error = ContentApiV2Error("is_a_folder_error")
ContentApiV2Error.other = ContentApiV2Error("other")

ErrorCode._unknown_error_validator = bv.Void()
ErrorCode._bad_request_validator = bv.Void()
ErrorCode._api_error_validator = bv.Void()
ErrorCode._access_error_validator = bv.Void()
ErrorCode._ratelimit_error_validator = bv.Void()
ErrorCode._unavailable_validator = bv.Void()
ErrorCode._other_validator = bv.Void()
ErrorCode._tagmap = {
    "unknown_error": ErrorCode._unknown_error_validator,
    "bad_request": ErrorCode._bad_request_validator,
    "api_error": ErrorCode._api_error_validator,
    "access_error": ErrorCode._access_error_validator,
    "ratelimit_error": ErrorCode._ratelimit_error_validator,
    "unavailable": ErrorCode._unavailable_validator,
    "other": ErrorCode._other_validator,
}

ErrorCode.unknown_error = ErrorCode("unknown_error")
ErrorCode.bad_request = ErrorCode("bad_request")
ErrorCode.api_error = ErrorCode("api_error")
ErrorCode.access_error = ErrorCode("access_error")
ErrorCode.ratelimit_error = ErrorCode("ratelimit_error")
ErrorCode.unavailable = ErrorCode("unavailable")
ErrorCode.other = ErrorCode("other")

FileIdOrUrl._file_id_validator = bv.String()
FileIdOrUrl._url_validator = bv.String()
FileIdOrUrl._path_validator = bv.String()
FileIdOrUrl._other_validator = bv.Void()
FileIdOrUrl._tagmap = {
    "file_id": FileIdOrUrl._file_id_validator,
    "url": FileIdOrUrl._url_validator,
    "path": FileIdOrUrl._path_validator,
    "other": FileIdOrUrl._other_validator,
}

FileIdOrUrl.other = FileIdOrUrl("other")

GetMarkdownArgs.file_id_or_url.validator = bv.Nullable(FileIdOrUrl_validator)
GetMarkdownArgs.enable_ocr.validator = bv.Boolean()
GetMarkdownArgs.embed_images.validator = bv.Boolean()
GetMarkdownArgs._all_field_names_ = set(
    [
        "file_id_or_url",
        "enable_ocr",
        "embed_images",
    ]
)
GetMarkdownArgs._all_fields_ = [
    ("file_id_or_url", GetMarkdownArgs.file_id_or_url.validator),
    ("enable_ocr", GetMarkdownArgs.enable_ocr.validator),
    ("embed_images", GetMarkdownArgs.embed_images.validator),
]

GetMarkdownAsyncCheckResult._in_progress_validator = bv.Void()
GetMarkdownAsyncCheckResult._complete_validator = GetMarkdownResult_validator
GetMarkdownAsyncCheckResult._failed_validator = GetMarkdownAsyncError_validator
GetMarkdownAsyncCheckResult._other_validator = bv.Void()
GetMarkdownAsyncCheckResult._tagmap = {
    "in_progress": GetMarkdownAsyncCheckResult._in_progress_validator,
    "complete": GetMarkdownAsyncCheckResult._complete_validator,
    "failed": GetMarkdownAsyncCheckResult._failed_validator,
    "other": GetMarkdownAsyncCheckResult._other_validator,
}

GetMarkdownAsyncCheckResult.in_progress = GetMarkdownAsyncCheckResult("in_progress")
GetMarkdownAsyncCheckResult.other = GetMarkdownAsyncCheckResult("other")

GetMarkdownAsyncError.error_code.validator = ErrorCode_validator
GetMarkdownAsyncError.error_details.validator = bv.Nullable(MarkdownConversionApiV2Error_validator)
GetMarkdownAsyncError._all_field_names_ = set(
    [
        "error_code",
        "error_details",
    ]
)
GetMarkdownAsyncError._all_fields_ = [
    ("error_code", GetMarkdownAsyncError.error_code.validator),
    ("error_details", GetMarkdownAsyncError.error_details.validator),
]

GetMarkdownResult.markdown.validator = bv.String()
GetMarkdownResult._all_field_names_ = set(["markdown"])
GetMarkdownResult._all_fields_ = [("markdown", GetMarkdownResult.markdown.validator)]

GetMetadataArgs.file_id_or_url.validator = bv.Nullable(FileIdOrUrl_validator)
GetMetadataArgs._all_field_names_ = set(["file_id_or_url"])
GetMetadataArgs._all_fields_ = [("file_id_or_url", GetMetadataArgs.file_id_or_url.validator)]

GetMetadataAsyncCheckResult._in_progress_validator = bv.Void()
GetMetadataAsyncCheckResult._complete_validator = GetMetadataResult_validator
GetMetadataAsyncCheckResult._failed_validator = GetMetadataAsyncError_validator
GetMetadataAsyncCheckResult._other_validator = bv.Void()
GetMetadataAsyncCheckResult._tagmap = {
    "in_progress": GetMetadataAsyncCheckResult._in_progress_validator,
    "complete": GetMetadataAsyncCheckResult._complete_validator,
    "failed": GetMetadataAsyncCheckResult._failed_validator,
    "other": GetMetadataAsyncCheckResult._other_validator,
}

GetMetadataAsyncCheckResult.in_progress = GetMetadataAsyncCheckResult("in_progress")
GetMetadataAsyncCheckResult.other = GetMetadataAsyncCheckResult("other")

GetMetadataAsyncError.error_code.validator = ErrorCode_validator
GetMetadataAsyncError.error_details.validator = bv.Nullable(MetadataExtractionApiV2Error_validator)
GetMetadataAsyncError._all_field_names_ = set(
    [
        "error_code",
        "error_details",
    ]
)
GetMetadataAsyncError._all_fields_ = [
    ("error_code", GetMetadataAsyncError.error_code.validator),
    ("error_details", GetMetadataAsyncError.error_details.validator),
]

GetMetadataResult.metadata_type.validator = MetadataType_validator
GetMetadataResult.metadata.validator = bv.Nullable(MetadataUnion_validator)
GetMetadataResult._all_field_names_ = set(
    [
        "metadata_type",
        "metadata",
    ]
)
GetMetadataResult._all_fields_ = [
    ("metadata_type", GetMetadataResult.metadata_type.validator),
    ("metadata", GetMetadataResult.metadata.validator),
]

GetTranscriptArgs.file_id_or_url.validator = bv.Nullable(FileIdOrUrl_validator)
GetTranscriptArgs.timestamp_level.validator = TimestampLevel_validator
GetTranscriptArgs.included_special_words.validator = bv.String()
GetTranscriptArgs.audio_language.validator = bv.String()
GetTranscriptArgs._all_field_names_ = set(
    [
        "file_id_or_url",
        "timestamp_level",
        "included_special_words",
        "audio_language",
    ]
)
GetTranscriptArgs._all_fields_ = [
    ("file_id_or_url", GetTranscriptArgs.file_id_or_url.validator),
    ("timestamp_level", GetTranscriptArgs.timestamp_level.validator),
    ("included_special_words", GetTranscriptArgs.included_special_words.validator),
    ("audio_language", GetTranscriptArgs.audio_language.validator),
]

GetTranscriptAsyncCheckResult._in_progress_validator = bv.Void()
GetTranscriptAsyncCheckResult._complete_validator = GetTranscriptResult_validator
GetTranscriptAsyncCheckResult._failed_validator = GetTranscriptAsyncError_validator
GetTranscriptAsyncCheckResult._other_validator = bv.Void()
GetTranscriptAsyncCheckResult._tagmap = {
    "in_progress": GetTranscriptAsyncCheckResult._in_progress_validator,
    "complete": GetTranscriptAsyncCheckResult._complete_validator,
    "failed": GetTranscriptAsyncCheckResult._failed_validator,
    "other": GetTranscriptAsyncCheckResult._other_validator,
}

GetTranscriptAsyncCheckResult.in_progress = GetTranscriptAsyncCheckResult("in_progress")
GetTranscriptAsyncCheckResult.other = GetTranscriptAsyncCheckResult("other")

GetTranscriptAsyncError.error_code.validator = ErrorCode_validator
GetTranscriptAsyncError.error_details.validator = bv.Nullable(ContentApiV2Error_validator)
GetTranscriptAsyncError._all_field_names_ = set(
    [
        "error_code",
        "error_details",
    ]
)
GetTranscriptAsyncError._all_fields_ = [
    ("error_code", GetTranscriptAsyncError.error_code.validator),
    ("error_details", GetTranscriptAsyncError.error_details.validator),
]

GetTranscriptResult.structured_transcript.validator = bv.Nullable(ApiStructuredTranscript_validator)
GetTranscriptResult._all_field_names_ = set(["structured_transcript"])
GetTranscriptResult._all_fields_ = [
    ("structured_transcript", GetTranscriptResult.structured_transcript.validator)
]

MarkdownConversionApiV2Error._server_error_validator = bv.String()
MarkdownConversionApiV2Error._user_error_validator = bv.String()
MarkdownConversionApiV2Error._unsupported_format_error_validator = bv.Void()
MarkdownConversionApiV2Error._link_download_disabled_error_validator = bv.Void()
MarkdownConversionApiV2Error._shared_link_password_protected_validator = bv.Void()
MarkdownConversionApiV2Error._limit_exceeded_error_validator = bv.Void()
MarkdownConversionApiV2Error._conversion_failure_error_validator = bv.Void()
MarkdownConversionApiV2Error._not_found_error_validator = bv.Void()
MarkdownConversionApiV2Error._is_a_folder_error_validator = bv.Void()
MarkdownConversionApiV2Error._other_validator = bv.Void()
MarkdownConversionApiV2Error._tagmap = {
    "server_error": MarkdownConversionApiV2Error._server_error_validator,
    "user_error": MarkdownConversionApiV2Error._user_error_validator,
    "unsupported_format_error": MarkdownConversionApiV2Error._unsupported_format_error_validator,
    "link_download_disabled_error": MarkdownConversionApiV2Error._link_download_disabled_error_validator,
    "shared_link_password_protected": MarkdownConversionApiV2Error._shared_link_password_protected_validator,
    "limit_exceeded_error": MarkdownConversionApiV2Error._limit_exceeded_error_validator,
    "conversion_failure_error": MarkdownConversionApiV2Error._conversion_failure_error_validator,
    "not_found_error": MarkdownConversionApiV2Error._not_found_error_validator,
    "is_a_folder_error": MarkdownConversionApiV2Error._is_a_folder_error_validator,
    "other": MarkdownConversionApiV2Error._other_validator,
}

MarkdownConversionApiV2Error.unsupported_format_error = MarkdownConversionApiV2Error(
    "unsupported_format_error"
)
MarkdownConversionApiV2Error.link_download_disabled_error = MarkdownConversionApiV2Error(
    "link_download_disabled_error"
)
MarkdownConversionApiV2Error.shared_link_password_protected = MarkdownConversionApiV2Error(
    "shared_link_password_protected"
)
MarkdownConversionApiV2Error.limit_exceeded_error = MarkdownConversionApiV2Error(
    "limit_exceeded_error"
)
MarkdownConversionApiV2Error.conversion_failure_error = MarkdownConversionApiV2Error(
    "conversion_failure_error"
)
MarkdownConversionApiV2Error.not_found_error = MarkdownConversionApiV2Error("not_found_error")
MarkdownConversionApiV2Error.is_a_folder_error = MarkdownConversionApiV2Error("is_a_folder_error")
MarkdownConversionApiV2Error.other = MarkdownConversionApiV2Error("other")

MediaDurationError.limit.validator = bv.Int32()
MediaDurationError._all_field_names_ = set(["limit"])
MediaDurationError._all_fields_ = [("limit", MediaDurationError.limit.validator)]

MetadataExtractionApiV2Error._server_error_validator = bv.String()
MetadataExtractionApiV2Error._user_error_validator = bv.String()
MetadataExtractionApiV2Error._unsupported_format_error_validator = bv.Void()
MetadataExtractionApiV2Error._link_download_disabled_error_validator = bv.Void()
MetadataExtractionApiV2Error._shared_link_password_protected_validator = bv.Void()
MetadataExtractionApiV2Error._limit_exceeded_error_validator = bv.Void()
MetadataExtractionApiV2Error._conversion_failure_error_validator = bv.Void()
MetadataExtractionApiV2Error._not_found_error_validator = bv.Void()
MetadataExtractionApiV2Error._is_a_folder_error_validator = bv.Void()
MetadataExtractionApiV2Error._other_validator = bv.Void()
MetadataExtractionApiV2Error._tagmap = {
    "server_error": MetadataExtractionApiV2Error._server_error_validator,
    "user_error": MetadataExtractionApiV2Error._user_error_validator,
    "unsupported_format_error": MetadataExtractionApiV2Error._unsupported_format_error_validator,
    "link_download_disabled_error": MetadataExtractionApiV2Error._link_download_disabled_error_validator,
    "shared_link_password_protected": MetadataExtractionApiV2Error._shared_link_password_protected_validator,
    "limit_exceeded_error": MetadataExtractionApiV2Error._limit_exceeded_error_validator,
    "conversion_failure_error": MetadataExtractionApiV2Error._conversion_failure_error_validator,
    "not_found_error": MetadataExtractionApiV2Error._not_found_error_validator,
    "is_a_folder_error": MetadataExtractionApiV2Error._is_a_folder_error_validator,
    "other": MetadataExtractionApiV2Error._other_validator,
}

MetadataExtractionApiV2Error.unsupported_format_error = MetadataExtractionApiV2Error(
    "unsupported_format_error"
)
MetadataExtractionApiV2Error.link_download_disabled_error = MetadataExtractionApiV2Error(
    "link_download_disabled_error"
)
MetadataExtractionApiV2Error.shared_link_password_protected = MetadataExtractionApiV2Error(
    "shared_link_password_protected"
)
MetadataExtractionApiV2Error.limit_exceeded_error = MetadataExtractionApiV2Error(
    "limit_exceeded_error"
)
MetadataExtractionApiV2Error.conversion_failure_error = MetadataExtractionApiV2Error(
    "conversion_failure_error"
)
MetadataExtractionApiV2Error.not_found_error = MetadataExtractionApiV2Error("not_found_error")
MetadataExtractionApiV2Error.is_a_folder_error = MetadataExtractionApiV2Error("is_a_folder_error")
MetadataExtractionApiV2Error.other = MetadataExtractionApiV2Error("other")

MetadataType._metadata_type_unknown_validator = bv.Void()
MetadataType._metadata_type_exif_validator = bv.Void()
MetadataType._metadata_type_media_validator = bv.Void()
MetadataType._metadata_type_pdf_validator = bv.Void()
MetadataType._metadata_type_office_validator = bv.Void()
MetadataType._other_validator = bv.Void()
MetadataType._tagmap = {
    "metadata_type_unknown": MetadataType._metadata_type_unknown_validator,
    "metadata_type_exif": MetadataType._metadata_type_exif_validator,
    "metadata_type_media": MetadataType._metadata_type_media_validator,
    "metadata_type_pdf": MetadataType._metadata_type_pdf_validator,
    "metadata_type_office": MetadataType._metadata_type_office_validator,
    "other": MetadataType._other_validator,
}

MetadataType.metadata_type_unknown = MetadataType("metadata_type_unknown")
MetadataType.metadata_type_exif = MetadataType("metadata_type_exif")
MetadataType.metadata_type_media = MetadataType("metadata_type_media")
MetadataType.metadata_type_pdf = MetadataType("metadata_type_pdf")
MetadataType.metadata_type_office = MetadataType("metadata_type_office")
MetadataType.other = MetadataType("other")

OfficeFileType._office_filetype_unknown_validator = bv.Void()
OfficeFileType._office_filetype_word_validator = bv.Void()
OfficeFileType._office_filetype_powerpoint_validator = bv.Void()
OfficeFileType._office_filetype_excel_validator = bv.Void()
OfficeFileType._other_validator = bv.Void()
OfficeFileType._tagmap = {
    "office_filetype_unknown": OfficeFileType._office_filetype_unknown_validator,
    "office_filetype_word": OfficeFileType._office_filetype_word_validator,
    "office_filetype_powerpoint": OfficeFileType._office_filetype_powerpoint_validator,
    "office_filetype_excel": OfficeFileType._office_filetype_excel_validator,
    "other": OfficeFileType._other_validator,
}

OfficeFileType.office_filetype_unknown = OfficeFileType("office_filetype_unknown")
OfficeFileType.office_filetype_word = OfficeFileType("office_filetype_word")
OfficeFileType.office_filetype_powerpoint = OfficeFileType("office_filetype_powerpoint")
OfficeFileType.office_filetype_excel = OfficeFileType("office_filetype_excel")
OfficeFileType.other = OfficeFileType("other")

TimestampLevel._unknown_validator = bv.Void()
TimestampLevel._sentence_validator = bv.Void()
TimestampLevel._word_validator = bv.Void()
TimestampLevel._other_validator = bv.Void()
TimestampLevel._tagmap = {
    "unknown": TimestampLevel._unknown_validator,
    "sentence": TimestampLevel._sentence_validator,
    "word": TimestampLevel._word_validator,
    "other": TimestampLevel._other_validator,
}

TimestampLevel.unknown = TimestampLevel("unknown")
TimestampLevel.sentence = TimestampLevel("sentence")
TimestampLevel.word = TimestampLevel("word")
TimestampLevel.other = TimestampLevel("other")

MetadataUnion._exif_validator = ApiExifMetadata_validator
MetadataUnion._media_validator = ApiMediaMetadata_validator
MetadataUnion._pdf_validator = ApiPdfMetadata_validator
MetadataUnion._office_validator = ApiOfficeMetadata_validator
MetadataUnion._other_validator = bv.Void()
MetadataUnion._tagmap = {
    "exif": MetadataUnion._exif_validator,
    "media": MetadataUnion._media_validator,
    "pdf": MetadataUnion._pdf_validator,
    "office": MetadataUnion._office_validator,
    "other": MetadataUnion._other_validator,
}

MetadataUnion.other = MetadataUnion("other")

ApiExifGpsMetadata.latitude.default = 0.0
ApiExifGpsMetadata.longitude.default = 0.0
ApiExifGpsMetadata.altitude.default = ""
ApiExifGpsMetadata.timestamp.default = ""
ApiExifGpsMetadata.datestamp.default = ""
ApiExifMetadata.image_width.default = 0
ApiExifMetadata.image_height.default = 0
ApiExifMetadata.camera_make.default = ""
ApiExifMetadata.camera_model.default = ""
ApiExifMetadata.lens_model.default = ""
ApiExifMetadata.date_time_original.default = ""
ApiExifMetadata.offset_time_original.default = ""
ApiExifMetadata.orientation.default = 0
ApiExifMetadata.exposure_time.default = ""
ApiExifMetadata.aperture_value.default = 0.0
ApiExifMetadata.iso_speed.default = 0
ApiExifMetadata.focal_length.default = ""
ApiExifMetadata.megapixels.default = 0.0
ApiExifMetadata.artist.default = ""
ApiExifMetadata.copyright.default = ""
ApiMediaMetadata.bitrate_bps.default = 0
ApiMediaMetadata.duration_s.default = 0.0
ApiMediaMetadata.creation_time.default = ""
ApiMediaStream.index.default = 0
ApiMediaStream.codec_type.default = ""
ApiMediaStream.codec_name.default = ""
ApiMediaStream.bitrate_bps.default = 0
ApiMediaStream.duration_s.default = 0.0
ApiMediaStream.width.default = 0
ApiMediaStream.height.default = 0
ApiMediaStream.frames_per_second.default = 0.0
ApiMediaStream.rotation.default = 0
ApiMediaStream.display_aspect_ratio.default = ""
ApiMediaStream.channels.default = 0
ApiMediaStream.channel_layout.default = ""
ApiMediaStream.sample_rate_s.default = 0
ApiMediaStream.language_iso_639.default = ""
ApiOfficeMetadata.file_type.default = OfficeFileType.office_filetype_unknown
ApiOfficeMetadata.creator.default = ""
ApiOfficeMetadata.company.default = ""
ApiOfficeMetadata.title.default = ""
ApiOfficeMetadata.subject.default = ""
ApiOfficeMetadata.keywords.default = ""
ApiOfficeMetadata.description.default = ""
ApiOfficeMetadata.total_edit_time_minutes.default = 0
ApiOfficeMetadata.pages.default = 0
ApiOfficeMetadata.words.default = 0
ApiOfficeMetadata.slides.default = 0
ApiOfficeMetadata.revision_number.default = ""
ApiPdfMetadata.pages.default = 0
ApiPdfMetadata.width.default = 0
ApiPdfMetadata.height.default = 0
ApiStructuredTranscript.transcript_locale.default = ""
ApiTranscriptSegment.text.default = ""
ApiTranscriptSegment.start_time.default = 0.0
ApiTranscriptSegment.end_time.default = 0.0
GetMarkdownArgs.enable_ocr.default = False
GetMarkdownArgs.embed_images.default = False
GetMarkdownAsyncError.error_code.default = ErrorCode.unknown_error
GetMarkdownResult.markdown.default = ""
GetMetadataAsyncError.error_code.default = ErrorCode.unknown_error
GetMetadataResult.metadata_type.default = MetadataType.metadata_type_unknown
GetTranscriptArgs.timestamp_level.default = TimestampLevel.unknown
GetTranscriptArgs.included_special_words.default = ""
GetTranscriptArgs.audio_language.default = ""
GetTranscriptAsyncError.error_code.default = ErrorCode.unknown_error
MediaDurationError.limit.default = 0
get_markdown_async = bb.Route(
    "get_markdown_async",
    1,
    False,
    GetMarkdownArgs_validator,
    async_.LaunchResultBase_validator,
    bv.Void(),
    {"auth": "app, user", "host": "api", "style": "rpc"},
)
get_markdown_async_check = bb.Route(
    "get_markdown_async/check",
    1,
    False,
    async_.PollArg_validator,
    GetMarkdownAsyncCheckResult_validator,
    async_.PollError_validator,
    {"auth": "app, user", "host": "api", "style": "rpc"},
)
get_metadata_async = bb.Route(
    "get_metadata_async",
    1,
    False,
    GetMetadataArgs_validator,
    async_.LaunchResultBase_validator,
    bv.Void(),
    {"auth": "app, user", "host": "api", "style": "rpc"},
)
get_metadata_async_check = bb.Route(
    "get_metadata_async/check",
    1,
    False,
    async_.PollArg_validator,
    GetMetadataAsyncCheckResult_validator,
    async_.PollError_validator,
    {"auth": "app, user", "host": "api", "style": "rpc"},
)
get_transcript_async = bb.Route(
    "get_transcript_async",
    1,
    False,
    GetTranscriptArgs_validator,
    async_.LaunchResultBase_validator,
    bv.Void(),
    {"auth": "app, user", "host": "api", "style": "rpc"},
)
get_transcript_async_check = bb.Route(
    "get_transcript_async/check",
    1,
    False,
    async_.PollArg_validator,
    GetTranscriptAsyncCheckResult_validator,
    async_.PollError_validator,
    {"auth": "app, user", "host": "api", "style": "rpc"},
)

ROUTES = {
    "get_markdown_async": get_markdown_async,
    "get_markdown_async/check": get_markdown_async_check,
    "get_metadata_async": get_metadata_async,
    "get_metadata_async/check": get_metadata_async_check,
    "get_transcript_async": get_transcript_async,
    "get_transcript_async/check": get_transcript_async_check,
}
