aboutsummaryrefslogtreecommitdiffhomepage
path: root/devel/schemata
blob: 728a46f214ac5a1597c48a62f6d00efbd41ffcd6 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
This file describes the schemata used for notmuch's structured output
format (currently JSON).

[]'s indicate lists.  List items can be marked with a '?', meaning
they are optional; or a '*', meaning there can be zero or more of that
item.  {}'s indicate an object that maps from field identifiers to
values.  An object field marked '?' is optional.  |'s indicate
alternates (e.g., int|string means something can be an int or a
string).

Common non-terminals
--------------------

# Number of seconds since the Epoch
unix_time = int

# Thread ID, sans "thread:"
threadid = string

# Message ID, sans "id:"
messageid = string

notmuch show schema
-------------------

# A top-level set of threads (do_show)
# Returned by notmuch show without a --part argument
thread_set = [thread*]

# Top-level messages in a thread (show_messages)
thread = [thread_node*]

# A message and its replies (show_messages)
thread_node = [
    message?,                 # present if --entire-thread or matched
    [thread_node*]            # children of message
]

# A message (show_message)
message = {
    # (format_message_json)
    id:             messageid,
    match:          bool,
    filename:	    string,
    timestamp:      unix_time, # date header as unix time
    date_relative:  string,   # user-friendly timestamp
    tags:           [string*],

    headers:        headers,
    body:           [part]
}

# A MIME part (show_message_body)
part = {
    # format_part_start_json
    id:             int|string, # part id (currently DFS part number)

    # format_part_encstatus_json
    encstatus?:     encstatus,

    # format_part_sigstatus_json
    sigstatus?:     sigstatus,

    # format_part_content_json
    content-type:   string,
    content-id?:    string,
    # if content-type starts with "multipart/":
    content:        [part*],
    # if content-type is "message/rfc822":
    content:        [{headers: headers, body: [part]}],
    # otherwise (leaf parts):
    filename?:      string,
    content-charset?: string,
    # A leaf part's body content is optional, but may be included if
    # it can be correctly encoded as a string.  Consumers should use
    # this in preference to fetching the part content separately.
    content?:       string
}

# The headers of a message (format_headers_json with raw headers
# and reply = FALSE) or a part (format_headers_message_part_json
# with pretty-printed headers)
headers = {
    Subject:        string,
    From:           string,
    To?:            string,
    Cc?:            string,
    Bcc?:           string,
    Date:           string
}

# Encryption status (format_part_encstatus_json)
encstatus = [{status: "good"|"bad"}]

# Signature status (format_part_sigstatus_json)
sigstatus = [signature*]

signature = {
    # signature_status_to_string
    status:         "none"|"good"|"bad"|"error"|"unknown",
    # if status is "good":
    fingerprint?:   string,
    created?:       unix_time,
    expires?:       unix_time,
    userid?:        string
    # if status is not "good":
    keyid?:         string
    # if the signature has errors:
    errors?:        int
}

notmuch search schema
---------------------

# --output=summary
summary = [thread*]

# --output=threads
threads = [threadid*]

# --output=messages
messages = [messageid*]

# --output=files
files = [string*]

# --output=tags
tags = [string*]

thread = {
    thread:         threadid,
    timestamp:      unix_time,
    date_relative:  string,   # user-friendly timestamp
    matched:        int,      # number of matched messages
    total:          int,      # total messages in thread
    authors:        string,   # comma-separated names with | between
                              # matched and unmatched
    subject:        string
}

notmuch reply schema
--------------------

reply = {
    # The headers of the constructed reply (format_headers_json with
    # raw headers and reply = TRUE)
    reply-headers: reply_headers,

    # As in the show format (format_part_json)
    original: message
}

reply_headers = {
    Subject:        string,
    From:           string,
    To?:            string,
    Cc?:            string,
    Bcc?:           string,
    In-reply-to:    string,
    References:     string
}