messages_appendix.cddl

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

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

agent-info = {
  0: text ; friendly-name
  1: text ; model-name
  ; ...
}

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

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

status = {
}

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

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

request-id = uint

; type key 1001
authentication-request = {
  request
  1: authentication-mechanism ; mechanism
  2: bytes ; salt
  3: uint ; cost
}

; type key 1002
authentication-response = {
  response
  1: authentication-response-result ; result
  2: bytes ; proof
}

certificate-fingerprint-pair = [
  challenger-fingerprint: bytes
  responder-fingerprint: bytes
]

; type key 1003
authentication-result = {
  1: authentication-result-result ; result
}


authentication-mechanism = &(
  hkdf-of-scrypt-of-psk: 1
)

authentication-response-result = &(
  ok: 0
  unknown-error: 1
  mechanism-unknown: 2
  salt-too-small: 3
  cost-too-low: 4
  cost-too-high: 5
  secret-unknown: 6
  calculation-took-too-long: 7
)

authentication-result-result = &(
  authenticated: 0
  unknown-error: 1
  proof-invalid: 2
)

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

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

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


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

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

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

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

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

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

; type key 108
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 109
presentation-connection-open-request = {
  request
  1: text ; presentation-id
  2: text ; url
}

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

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

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

; type key 113
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 16
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 17
remote-playback-availability-request = {
  request
  1: [* text] ; urls
  2: microseconds ; watch-duration
  3: int ; watch-id
}

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

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

; type key 115
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 116
remote-playback-start-response = {
  response
  1: &result ; result
  ? 2: remote-playback-state ; state
}

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

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

; type key 119
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 19
remote-playback-modify-request = {
  request
  1: remote-playback-id ; remote-playback-id
  2: remote-playback-controls ; controls
)

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

; type key 21
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
}