# -*- 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 riviera.ApiExifGpsMetadata.latitude: Latitude / longitude in decimal
        degrees (positive = N/E, negative = S/W).
    :ivar riviera.ApiExifGpsMetadata.altitude: Altitude in meters, as reported
        by the source (string to preserve the original representation, which may
        include a reference direction).
    :ivar riviera.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 riviera.ApiExifMetadata.date_time_original: Capture time in the
        EXIF-provided format (local time of the camera).
    :ivar riviera.ApiExifMetadata.offset_time_original: Timezone offset for
        `date_time_original`, e.g. "+09:00".
    :ivar riviera.ApiExifMetadata.orientation: EXIF orientation value (1-8). See
        the EXIF spec; 1 is the normal upright orientation.
    :ivar riviera.ApiExifMetadata.exposure_time: fraction in string form, e.g.
        "1/250"
    :ivar riviera.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 riviera.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 riviera.ApiMediaStream.codec_type: "audio", "video", etc.
    :ivar riviera.ApiMediaStream.width: Video-specific fields (zero / empty for
        audio streams).
    :ivar riviera.ApiMediaStream.display_aspect_ratio: e.g. "16:9"
    :ivar riviera.ApiMediaStream.channels: Audio-specific fields (zero / empty
        for video streams).
    :ivar riviera.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 riviera.ApiOfficeMetadata.pages: Word only.
    :ivar riviera.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 riviera.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 riviera.ContentApiV2Error.not_found_error: The referenced file does
        not exist or is not accessible.
    :ivar riviera.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 riviera.ErrorCode.bad_request: 400
    :ivar riviera.ErrorCode.api_error: 409
    :ivar riviera.ErrorCode.access_error: 403
    :ivar riviera.ErrorCode.ratelimit_error: 429
    :ivar riviera.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 riviera.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 riviera.GetMarkdownArgs.enable_ocr: Enable OCR for PDF documents.
        Processing is slower when enabled.
    :ivar riviera.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 riviera.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 riviera.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 riviera.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 riviera.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 riviera.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 riviera.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 riviera.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 riviera.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 riviera.MarkdownConversionApiV2Error.not_found_error: The referenced
        file does not exist or is not accessible.
    :ivar riviera.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 riviera.MetadataExtractionApiV2Error.not_found_error: The referenced
        file does not exist or is not accessible.
    :ivar riviera.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,
}

