messages_appendix.cddl

; type key 100
agent-info-request = {
  request
}

; type key 101
agent-info-response = {
  response
  1: agent-info ; agent-info
}

agent-info = {
  0: text ; display-name
  1: text ; model-name
  ? 2: bool ; receives-audio
  ? 3: bool ; receives-video
}

; type key 102
agent-status-request = {
  request
  ? 1: status ; status
}

; type key 103
agent-status-response = {
  response
  ? 1: status ; status
}

status = {}

request = (
 0: request-id ; request-id
)

response = (
 0: request-id ; request-id
)

request-id = uint

microseconds = uint

; type key 1001
auth-capabilities = {
  0: uint ; psk-ease-of-input
  1: [* psk-input-method] ; psk-input-methods
}

psk-input-method = &(
  numeric: 0
  qr-code: 1
)

; type key 1002
auth-spake2-need-psk = {
}

; type key 1003
auth-spake2-message = {
  1 : bytes .size 32 ; message
}

; type key 1004
auth-spake2-confirmation = {
  1 : bytes .size 32 ; confirmation
}

; type key 1005
auth-status = {
  1 : auth-status-result ; result
}

auth-status-result = &(
  authenticated: 0
  unknown-error: 1
  timeout: 2
  secret-unknown: 3
  validation-took-too-long : 4
  proof-invalid: 5
)

psk-input-method = &(
  numeric: 0
  alphanumeric: 1
  qr-code: 2
)

; type key 108
presentation-url-availability-request = {
  request
  1: [1* text] ; urls
  2: microseconds ; watch-duration
  3: uint ; watch-id
}

; type key 109
presentation-url-availability-response = {
  response
  1: [1* url-availability] ; url-availabilities
}

; type key 110
presentation-url-availability-event = {
  1: uint ; watch-id
  2: [1* url-availability] ; url-availabilities
}

; idea: use HTTP response codes?
url-availability = &(
  available: 0
  unavailable: 1
  invalid: 10
)

; type key 111
presentation-start-request = {
  request
  1: text ; presentation-id
  2: text ; url
  3: [* http-header] ; headers
}

http-header = [
  key: text
  value: text
]

; type key 112
presentation-start-response = {
  response
  1: &result ; result
  2: uint ; connection-id
}

; type key 113
presentation-termination-request = {
  request
  1: text ; presentation-id
  2: &(
    controller-called-terminate: 10
    user-terminated-via-controller: 11
    unknown: 255
  ) ; reason
}

; type key 114
presentation-termination-response = {
  response
  1: &result ; result
}

; type key 115
presentation-termination-event = {
  1: text ; presentation-id
  2: &(
    receiver-called-terminate: 1
    user-terminated-via-receiver: 2
    controller-called-terminate: 10
    user-terminated-via-controller: 11
    receiver-replaced-presentation: 20
    receiver-idle-too-long: 30
    receiver-attempted-to-navigate: 31
    receiver-powering-down: 100
    receiver-crashed: 101
    unknown: 255
  ) ; reason
}

; type key 116
presentation-connection-open-request = {
  request
  1: text ; presentation-id
  2: text ; url
}

; type key 117
presentation-connection-open-response = {
  response
  1: &result ; result
  2: uint; connection-id
}

; type key 118
presentation-connection-close-request = {
  request
  1: uint ; connection-id
}

; type key 119
presentation-connection-close-response = {
  response
  1: &result ; result
}

; type key 120
presentation-connection-close-event = {
  1: uint; connection-id
  2: &(
    close-method-called: 1
    connection-object-discarded: 10
    unrecoverable-error-while-sending-or-receiving-message: 100
  ) ; reason
  ? 3: text ; error-message
}

; type key 12
presentation-connection-message = {
  1: uint ; connection-id
  2: bytes / text ; message
}

result = (
  success: 1
  invalid-url: 10
  invalid-presentation-id: 11
  timeout: 100
  transient-error: 101
  permanent-error: 102
  terminating: 103
  unknown-error: 199
)

; type key 121
remote-playback-availability-request = {
  request
  1: [* text] ; urls
  2: microseconds ; watch-duration
  3: int ; watch-id
}

; type key 122
remote-playback-availability-response = {
  response
  url-availabilities: [* url-availability]
}

; type key 123
remote-playback-availability-event = {
  1: int ; watch-id
  2: [* url-availability] ; url-availabilities
}

; type key 124
remote-playback-start-request = {
  request
  1: remote-playback-id ; remote-playback-id
  2: [* text] ; urls
  ? 3: [* text] ; text-track-urls
  ? 4: [* http-header] ; headers
  ? 5: remote-playback-controls ; controls
}

; type key 125
remote-playback-start-response = {
  response
  1: &result ; result
  ? 2: remote-playback-state ; state
}

; type key 126
remote-playback-termination-request = {
  request
  1: remote-playback-id ; remote-playback-id
  2: &(
    user-terminated-via-controller: 11
    unknown: 255
  ) ; reason
}

; type key 127
remote-playback-termination-response = {
  response
  1: &result ; result
}

; type key 128
remote-playback-termination-event = {
 1: remote-playback-id ; remote-playback-id
 2: &(
    receiver-called-terminate: 1
    user-terminated-via-receiver: 2
    receiver-idle-too-long: 30
    receiver-powering-down: 100
    receiver-crashed: 101
    unknown: 255
  ) ; reason
}

; type key 129
remote-playback-modify-request = {
  request
  1: remote-playback-id ; remote-playback-id
  2: remote-playback-controls ; controls
)

; type key 130
remote-playback-modify-response = {
  response
  1: &result ; result
  ? 2: remote-playback-state ; state
}

; type key 131
remote-playback-state-event = {
  1: remote-playback-id ; remote-playback-id
  2: remote-playback-state ; state
}

remote-playback-id = uint

remote-playback-controls = {
  ? 1: url ; source
  ? 2: &(none, metadata, auto) ; preload
  ? 3: bool ; loop
  ? 4: bool ; paused
  ? 5: bool ; muted
  ? 6: float ; volume
  ? 7: media-time ; seek
  ? 8: media-time ; fast-seek
  ? 9: float ; playback-rate
  ? 10: url ; poster
  ? 11: [* text] ; enabled-audio-track-ids
  ? 12: text ; selected-video-track-id
  ? 13: [* added-text-track] ; added-text-tracks
  ? 14: [* changed-text-track] ; changed-text-tracks
}

remote-playback-state = {
  ? 1: &(rate: bool,
         preload: bool,
         poster: bool,
         added-text-track:
         bool,
         added-cues: bool) ; supports
  ? 2: url ; source
  ? 3: &(
    empty: 0
    idle: 1
    loading: 2
    no-source: 3
  ) ; loading
  ? 4: &(
    nothing: 0
    metadata: 1
    current: 2
    future: 3
    enough: 4
  ) ; loaded
  ? 5: media-error : error
  ? 6: media-time / unknown; epoch
  ? 7: media-time / unknown / forever ; duration
  ? 8: [* media-time-range] ; buffered-time-ranges
  ? 9: [* media-time-range] ; seekable-time-ranges
  ? 10: [* media-time-range] ; played-time-ranges
  ? 11: media-time ; position
  ? 12: float : playbackRate
  ? 13: bool ; paused
  ? 14: bool ; seeking
  ? 15: bool ; stalled
  ? 16: bool ; ended
  ? 17: float ; volume
  ? 18: bool ; muted
  ? 19: video-resolution / unknown ; resolution
  ? 20: [* audio-track-state] audio-tracks
  ? 21: [* video-track-state] video-tracks
  ? 22: [* text-track-state] text-tracks
}

added-text-track = {
  1: &(
    subtitles
    captions
    descriptions
    chapters
    metadata
  ) ; kind
  ? 2: text ; label
  ? 3: text ; language
}

changed-text-track = {
  1: text ; id
  2: mode ; mode
  ? 3: [* text-track-cue] ; added-cues
  ? 4: [* text] ; removed-cue-ids
}

text-track-mode = &(
  disabled
  showing
  hidden
)

text-track-cue = {
  1: text ; id
  2: media-time-range ; range
  3: text ; text
}

media-time-range = [
  start: media-time,
  end: media-time
]

media-time = [
  value: uint
  scale: uint
]

unknown = 0
forever = 1

media-error = [
  code: &(
    user-aborted: 1
    network-error: 2
    decode-error: 3
    source-not-supported: 4
    unknown-error: 5
  )
  message: text
]

track-state = (
  1: text ; id
  2: text ; label
  3: text ; language
)

audio-track-state = {
  track-state
  4: bool ; enabled
}

video-track-state = {
  track-state
  5 : bool ; selected
}

text-track-state = {
  track-state
  6 : mode ; text-track-mode
}

; type key 132
streaming-capabilities-request = {
  request
}

; type key 133
streaming-capabilities-response = {
  response
  1: streaming-capabilities ; streaming-capabilities
}

streaming-capabilities = {
  0: [* receive-audio-capability] ; receive-audio
  1: [* receive-video-capability] ; receive-video
}

format = {
  0: string ; name
  1: [* format-parameter] ; parameters
}

format-parameter = {
  0: string ; key
  1: bytes ; value
}

receive-audio-capability = {
  0: format ; codec
  ? 1: uint ; max-audio-channels
  ? 2: uint ; min-bit-rate
}

video-resolution = {
  0: uint ; height
  1: uint ; width
}

receive-video-capability = {
  0: format ; codec
  ? 1: video-resolution ; max-resolution
  ? 2: uint ; max-frames-per-second
  ? 3: uint ; max-pixels-per-second
  ? 4: uint ; min-bit-rate
  ? 5: ratio ; aspect-ratio
  ? 6: [* string] ; color-profiles
  ? 7: [* video-resolution] ; native-resolutions
  ? 8: bool ; supports-scaling
}

; type key 134
streaming-session-start-request = {
  request
  1: uint; streaming-session-id
  2: [* media-stream-offer] ;  stream-offers
  3: microseconds ; stats-interval
}

; type key 135
streaming-session-start-response = {
  response
  1: &result ; result
  2: [* media-stream-request] ; stream-requests
  3: microseconds ; stats-interval
}

; type key 136
streaming-session-modify-request = {
  request
  1: uint ; streaming-session-id
  2: [* media-stream-request] ; stream-requests
}

; type key 137
streaming-session-modify-response = {
  response
  1: &result ; result
}

; type key 138
streaming-session-terminate-request = {
  request
  1 : uint ; streaming-session-id
}

; type key 139
streaming-session-terminate-response = {
  response
}

; type key 140
streaming-session-terminate-event = {
  1 : uint ; streaming-session-id
}

media-stream-offer = {
  1 : uint ; media-stream-id
  ? 2 : text ; friendly-name
  ? 3 : [1* audio-encoding-offer] ; audio
  ? 4 : [1* video-encoding-offer] ; video
}

media-stream-request = {
  1 : uint ; media-stream-id
  ? 2 : audio-encoding-request ; audio
  ? 3 : video-encoding-request ; video
}

audio-encoding-offer = {
  1 : uint ; encoding-id
  2 : text ; codec
  3 : uint ; time-scale
  ? 4 : uint ; default-duration
}

video-encoding-offer = {
  1 : uint ; encoding-id
  2 : text ; codec
  3 : uint ; time-scale
  ? 4 : uint ; default-duration
  ? 5 : video-rotation ; default-rotation
}

audio-encoding-request = {
  1: uint ; encoding-id
}

video-encoding-request = {
  1 : uint ; encoding-id
  ? 2 : video-resolution ; target-resolution
  ? 3 : float32 ; max-frames-per-second
}

; type key 13
audio-frame = [
  encoding-id: uint
  start-time: uint
  payload: bytes
  ? optional: {
    ? 0: uint ; duration
    ? 1: media-time ; sync-time
  }
]

; type key 14
video-frame = {
  0: uint ; encoding-id
  1: uint ; sequence-number
  ? 2: [* int] ; depends-on
  3: uint ; start-time
  ? 4: uint ; duration
  5: bytes ; payload
  ? 6: uint ; rotation
  ? 7: media-time ; sync-time
}

; type key 141
video-frame-request = {
 1: uint; encoding-id
 2: uint; sequence-number
 ? 3: uint; highest-decoded-frame-sequence-number
}

ratio = [
  antecedent: uint
  consequent: uint
]


; type key 142
streaming-session-sender-stats-event = {
  1: uint; streaming-session-id
  2: microseconds ; system-time
  ? 3: [1* {
    1: uint ; encoding-id
    ? 2: uint ; cumulative-sent-frames
    ? 3: microseconds ; cumulative-encode-delay
  }] ; audio
  ? 4: [1* {
    1: uint ; encoding-id
    ? 2: microseconds ; cumulative-sent-duration
    ? 3: microseconds ; cumulative-encode-delay
    ? 4: uint ; cumulative-dropped-frames
  }] ; video
}

; type key 143
streaming-session-receiver-stats-event = {
  1: uint; streaming-session-id
  2: microseconds ; system-time
  ? 3: [1* {
    1: uint ; encoding-id
    ? 2: microseconds ; cumulative-received-duration
    ? 3: microseconds ; cumulative-lost-duration
    ? 3: microseconds ; cumulative-jitter-buffer-delay
    ? 4: microseconds ; cumulative-decode-delay
  }] ; audio
  ? 4: [1* {
    1: uint ; encoding-id
    ? 2: uint ; cumulative-decoded-frames
    ? 3: uint ; cumulative-lost-frames
    ? 4: microseconds ; cumulative-jitter-buffer-delay
    ? 5: microseconds ; cumulative-decode-delay
  }] ; video
}