schema.graphql

type AnnotatedDoc {
	"""
	Official short identifier for this document
	"""
	id: UUID!
	"""
	Full title of the document
	"""
	title: String!
	"""
	Date and time this document was written or created
	"""
	date: Date
	"""
	When the document was bookmarked by the current user, if it was.
	"""
	bookmarkedOn: Date
	"""
	The original source(s) of this document, the most important first.
	"""
	sources: [SourceAttribution!]!
	"""
	Where the source document came from, maybe the name of a collection
	"""
	collection: DocumentCollection
	"""
	The genre of the document, used to group similar ones
	"""
	genre: String
	"""
	Images of each source document page, in order
	"""
	pageImages: IiifImages
	"""
	The people involved in producing this document, including the original
	author, translators, and annotators
	"""
	contributors: [Contributor!]!
	"""
	Is this document a reference source (unstructured list of words)?
	Otherwise, it is considered a structured document with a translation.
	"""
	isReference: Boolean!
	"""
	The audio recording resource for this entire document
	"""
	audioRecording: AudioSlice
	"""
	Arbitrary number used for manually ordering documents in a collection.
	For collections without manual ordering, use zero here.
	"""
	orderIndex: Int!
	"""
	URL-ready slug for this document, generated from the title
	"""
	slug: String!
	"""
	Segments of the document paired with their respective rough translations
	"""
	translatedPages: [DocumentPage!]
	"""
	All the words contained in this document, dropping structural formatting
	like line and page breaks.
	"""
	forms(start: Int, end: Int): [AnnotatedForm!]!
	formCount: Int!
	"""
	All words in the document that have unanalyzed or unfamiliar parts.
	These words need to be corrected or reviewed further.
	"""
	unresolvedForms: [AnnotatedForm!]!
	"""
	Collection chapters that contain this document.
	"""
	chapters: [CollectionChapter!]
}

"""
A single word in an annotated document.
One word contains several layers of interpretation, including the original
source text, multiple layers of linguistic annotation, and annotator notes.
TODO Split into two types, one for migration and one for SQL + GraphQL
"""
type AnnotatedForm {
	"""
	Original source text
	"""
	source: String!
	"""
	A normalized version of the word
	"""
	normalizedSource: String
	"""
	Underlying phonemic representation of this word
	"""
	phonemic: String
	"""
	English gloss for the whole word
	"""
	englishGloss: [String!]!
	"""
	Further details about the annotation layers, including uncertainty
	"""
	commentary: String
	"""
	The character index of a mid-word line break, if there is one
	"""
	lineBreak: Int
	"""
	The character index of a mid-word page break, if there is one
	"""
	pageBreak: Int
	"""
	Position of the form within the context of its parent document
	"""
	position: PositionInDocument!
	"""
	The date and time this form was recorded
	"""
	dateRecorded: Date
	"""
	The audio for this word that was ingested from GoogleSheets, if there is any.
	"""
	ingestedAudioTrack: AudioSlice
	"""
	The root morpheme of the word.
	For example, a verb form glossed as "he catches" might have a root morpheme
	corresponding to "catch."
	"""
	root: WordSegment
	romanizedSource(system: CherokeeOrthography!): String
	segments(system: CherokeeOrthography!): [WordSegment!]!
	"""
	All other observed words with the same root morpheme as this word.
	"""
	similarForms: [AnnotatedForm!]!
	"""
	The document that contains this word.
	"""
	document: AnnotatedDoc
	"""
	Number of words preceding this one in the containing document
	"""
	index: Int!
	"""
	Unique identifier of the containing document
	"""
	documentId: UUID!
	"""
	Unique identifier of this form
	"""
	id: UUID!
	"""
	A slices of audio associated with this word in the context of a document.
	This audio has been selected by an editor from contributions, or is the
	same as the ingested audio track, if one is available.
	"""
	editedAudio: [AudioSlice!]!
	"""
	Audio for this word that has been recorded by community members. Will be
	empty if user does not have access to uncurated contributions.
	TODO! User guard for contributors only
	"""
	userContributedAudio: [AudioSlice!]!
	"""
	Get comments on this word
	"""
	comments: [Comment!]!
}

"""
A single word in an annotated document that can be edited.
All fields except id are optional.
"""
input AnnotatedFormUpdate {
	"""
	Unique identifier of the form
	"""
	id: UUID!
	"""
	Possible update to source content
	"""
	source: String
	"""
	Possible update to commentary
	"""
	commentary: String
	"""
	Updated segments
	"""
	segments: [MorphemeSegmentUpdate!]
}

"""
Element within a spreadsheet before being transformed into a full document.
"""
union AnnotatedSeg = AnnotatedForm | LineBreak

"""
Request to attach user-recorded audio to a word
"""
input AttachAudioToWordInput {
	"""
	Word to bind audio to
	"""
	wordId: UUID!
	"""
	A URL to a Cloudfront-proxied user-recorded pronunciation of a word.
	A new resource will be created to represent the recording if one does not exist already
	"""
	contributorAudioUrl: String!
}

"""
A segment of audio representing a document, word, phrase,
or other audio unit
"""
type AudioSlice {
	"""
	The unique id for this audio slice. Will not be present if audio has not been inserted
	"""
	sliceId: String
	"""
	The audio resource this audio slice is taken from, generally pulled from the DRS API
	"""
	resourceUrl: String!
	"""
	An audio slice this slice is a subunit of, if there is one
	"""
	parentTrack: String
	"""
	When the track was recorded, if available
	"""
	recordedAt: Date
	"""
	Which user recorded the tracked, if uploaded by a user
	"""
	recordedBy: User
	"""
	True if audio should be shown to Readers.
	"""
	includeInEditedCollection: Boolean!
	"""
	Last Editor to decide if audio should be included in edited collection.
	"""
	editedBy: User
	"""
	This slice's relative position to other slices within an audio resource
	"""
	index: Int!
	"""
	The time (in seconds) in the parent track where this slice begins.
	"""
	startTime: Int
	"""
	The time (in seconds) in the parent track where this slice ends.
	"""
	endTime: Int
}


"""
One representation of Cherokee phonology.
There are several different writing systems for Cherokee phonology and we
want to convert between them.
This type enumerates all of the systems that we support and provides
conversion from our internal orthography into any of these.
"""
enum CherokeeOrthography {
	TAOC
	CRG
	LEARNER
}

"""
Structure to represent a single chapter. Used to send data to the front end.
"""
type CollectionChapter {
	"""
	UUID for the chapter
	"""
	id: UUID!
	"""
	Full title of the chapter
	"""
	title: String!
	"""
	ID of WordPress page with text of the chapter
	"""
	wordpressId: Int
	"""
	Order within the parent chapter or collection
	"""
	indexInParent: Int!
	"""
	Whether the chapter is an "Intro" or "Body" chapter
	"""
	section: CollectionSection!
	"""
	Full path of the chapter
	"""
	path: [String!]!
	slug: String!
	document: AnnotatedDoc
	"""
	Breadcrumbs from the top-level archive down to where this document lives.
	"""
	breadcrumbs: [DocumentCollection!]!
}

"""
Enum to represent the sections in an edited collection
"""
enum CollectionSection {
	INTRO
	BODY
	CREDIT
}

"""
A comment a user has made on some piece of a document.
"""
type Comment {
	"""
	Unique identifier of this comment
	"""
	id: UUID!
	"""
	When the comment was posted
	"""
	postedAt: DateTime!
	"""
	Who posted the comment
	"""
	postedBy: User!
	"""
	The text of the comment
	"""
	textContent: String!
	"""
	An optional classification of the comment's content
	"""
	commentType: CommentType
	"""
	Whether the comment has been edited since it was posted
	"""
	edited: Boolean!
}

"""
Type representing the object that a comment is attached to
"""
union CommentParent = AnnotatedForm | DocumentParagraph

"""
An enum listing the possible types that a comment could be attached to
"""
enum CommentParentType {
	WORD
	PARAGRAPH
}

"""
A type describing the kind of comment being made
"""
enum CommentType {
	STORY
	SUGGESTION
	QUESTION
}

"""
Used for updating comments.
All fields except id are optional.
"""
input CommentUpdate {
	id: UUID!
	"""
	The text of the comment
	"""
	textContent: String
	commentType: CommentType
	edited: Boolean!
}

"""
A block of content, which may be one of several types.
Each page contains several blocks.

This type is intended to enable a custom page builder on the front-end for
content editors.
"""
union ContentBlock = Markdown | Gallery

"""
An individual or organization that contributed to the creation or analysis
of a particular document or source. Each contributor has a name and a role
that specifies the type of their contributions.
"""
type Contributor {
	"""
	Full name of the contributor
	"""
	name: String!
	"""
	The role that defines most of their contributions to the associated item
	"""
	role: String!
	details: ContributorDetails
}

"""
Basic personal details of an individual contributor, which can be retrieved
from a particular instance of [`Contributor`].

They may have transcribed a handwritten manuscript, translated it into
English, or analyzed it for linguistic information.
This information can be used to track who contributed to the development of
each individual document, and track contributions to the archive as a whole.
"""
type ContributorDetails {
	"""
	Full name of this person, this exact string must be used to identify
	them elsewhere, like in the attribution for a particular document.
	"""
	fullName: String!
	"""
	Alternate name of this person, may be in a different language or writing
	system. Used only for descriptive purposes.
	"""
	alternateName: String
	"""
	The optional date that this contributor was born on.
	"""
	birthDate: Date
}

"""
Request to update if a piece of audio should be included in an edited collection
"""
input CurateWordAudioInput {
	"""
	Word audio is attached to
	"""
	wordId: UUID!
	"""
	Audio to include/exclude
	"""
	audioSliceId: UUID!
	"""
	New value
	"""
	includeInEditedCollection: Boolean!
}

type Date {
	"""
	The year of this date
	"""
	year: Int!
	"""
	The month of this date
	"""
	month: Int!
	"""
	The day of this date
	"""
	day: Int!
	"""
	Formatted version of the date for humans to read
	"""
	formattedDate: String!
}

input DateInput {
	day: Int!
	month: Int!
	year: Int!
}

type DateTime {
	"""
	UNIX timestamp of the datetime, useful for sorting
	"""
	timestamp: Int!
	"""
	Just the Date component of this DateTime, useful for user-facing display
	"""
	date: Date!
}

"""
Input object for deleting an existing comment
"""
input DeleteCommentInput {
	"""
	ID of the comment to delete
	"""
	commentId: UUID!
}

"""
Delete a contributor attribution for a document based on the two ids
"""
input DeleteContributorAttribution {
	documentId: UUID!
	contributorId: UUID!
}

type DocumentCollection {
	"""
	Full name of this collection
	"""
	name: String!
	"""
	URL-ready slug for this collection, generated from the name
	"""
	slug: String!
	"""
	All documents that are part of this collection
	TODO Try to unify this return type into AnnotatedDoc
	This probably requires adding a document_ids field so that we can just
	pass that to the dataloader below.
	"""
	documents: [DocumentReference!]!
}

"""
Used for updating document metadata.
All fields except id are optional.
"""
input DocumentMetadataUpdate {
	id: UUID!
	title: String
	writtenAt: DateInput
}

type DocumentPage {
	"""
	One-indexed page number
	"""
	pageNumber: String!
	"""
	Scan of this page as a IIIF resource, if there is one
	"""
	image: PageImage
	"""
	Contents of this page as a list of paragraphs
	"""
	paragraphs: [DocumentParagraph!]!
}

"""
One paragraph within a [`DocumentPage`]
"""
type DocumentParagraph {
	"""
	Unique identifier for this paragraph
	"""
	id: UUID!
	"""
	English translation of the whole paragraph
	"""
	translation: String!
	"""
	1-indexed position of this paragraph in a document
	"""
	index: Int!
	"""
	Source text of the paragraph broken down into words
	"""
	source: [AnnotatedSeg!]!
	"""
	Get comments on this paragraph
	"""
	comments: [Comment!]!
}

"""
Reference to a document with a limited subset of fields, namely no contents
of the document.
"""
type DocumentReference {
	"""
	Database ID for the document
	"""
	id: UUID!
	"""
	Unique short name
	"""
	shortName: String!
	"""
	Long title of the document
	"""
	title: String!
	"""
	Date the document was produced (or `None` if unknown)
	"""
	date: Date
	"""
	Index of the document within its group, used purely for ordering
	"""
	orderIndex: Int!
	"""
	URL slug for this document
	"""
	slug: String!
}

"""
The kind of a document in terms of what body it lives within. A reference
document is a dictionary or grammar for example, while a corpus document
might be a letter, journal, or notice.
"""
enum DocumentType {
	REFERENCE
	CORPUS
}

"""
Structure to represent an edited collection. Missing certain fields and chapters in it.
Used for sending data to the front end
"""
type EditedCollection {
	"""
	UUID for the collection
	"""
	id: UUID!
	"""
	Full title of the collection
	"""
	title: String!
	"""
	ID of WordPress menu for navigating the collection
	"""
	wordpressMenuId: Int
	"""
	URL slug for the collection, like "cwkw"
	"""
	slug: String!
	chapters: [CollectionChapter!]
}


type FormsInTime {
	start: Date
	end: Date
	forms: [AnnotatedForm!]!
}

"""
A gallery of images, which may be rendered as a slideshow or lightbox.
"""
type Gallery {
	mediaUrls: [String!]!
}

"""
A rectangle slice of something, usually a large document image.

Units are a percentage of the containing document.
This is more useful than pixels because we can more easily compare
geometries between images of different resolutions. For example, we could identify
all items in any bottom-right corner with Geometry(90%, 90%, 100%, 100%).
Physical units would be better, but IIIF only allows pixels and percentages.

Potential use case:
Each document is represented by an ordered list of [AnnotatedForm]s. Each
form has some geometry on the source image. There are a bunch of other
annotations on the source image that are unordered. These may be specific
syllabary characters, notes about the handwriting, etc. Using MongoDB
comparison queries, we can request a list of all spatial annotations
on the same document that lie within or around the geometry of this specific word.
"""
type Geometry {
	xMin: Float!
	yMin: Float!
	xMax: Float!
	yMax: Float!
}


type IiifImages {
	"""
	Information about the data source for this set of images
	"""
	source: ImageSource!
	"""
	List of urls for all the images in this collection
	"""
	urls: [String!]!
}

type ImageSource {
	"""
	Base URL for the IIIF server
	"""
	url: String!
}


"""
A scalar that can represent any JSON value.
"""
scalar JSON

"""
Start of a new line
"""
type LineBreak {
	"""
	Index of this line break within the document. i.e. Indicates the start
	of line X.
	"""
	index: Int!
}

"""
A block of prose content, formatted with [Markdown](https://commonmark.org/).
"""
type Markdown {
	content: String!
}

"""
One particular morpheme and all the known words that contain that exact morpheme.
"""
type MorphemeReference {
	"""
	Phonemic shape of the morpheme.
	"""
	morpheme: String!
	"""
	List of words that contain this morpheme.
	"""
	forms: [AnnotatedForm!]!
}

"""
A single unit of meaning and its gloss which can be edited.
"""
input MorphemeSegmentUpdate {
	"""
	Which Cherokee representation system is this segment written with?
	"""
	system: CherokeeOrthography
	"""
	Source language representation of this segment.
	"""
	morpheme: String!
	"""
	Target language representation of this segment.
	"""
	gloss: String!
	"""
	This field determines what character should separate this segment from
	the next one when reconstituting the full segmentation string.
	"""
	role: WordSegmentRole!
}

"""
A concrete representation of a particular functional morpheme.
"""
type MorphemeTag {
	"""
	Internal representation of this functional item, which may be one or
	more word parts in the raw annotation. For example, ["X", "Y"] could map
	to "Z" in a particular display format.
	"""
	internalTags: [String!]!
	"""
	How this morpheme is represented in a gloss
	"""
	tag: String!
	"""
	Plain English title of the morpheme tag
	"""
	title: String!
	"""
	How this morpheme looks in original language data
	"""
	shape: String
	"""
	URL to an external page with more details about this morpheme.
	"""
	detailsUrl: String
	"""
	A prose description of what this morpheme means and how it works in
	context.
	"""
	definition: String!
	"""
	What kind of morpheme is this? Examples are "Prepronominal Prefix" or
	"Aspectual Suffix"
	"""
	morphemeType: String!
	"""
	Overrides the segment type of instances of this tag.
	"""
	roleOverride: WordSegmentRole
}

type Mutation {
	"""
	Mutation must have at least one visible field for introspection to work
	correctly, so we just provide an API version which might be useful in
	the future.
	"""
	apiVersion: String!
	"""
	Delete a comment.
	Will fail if the user making the request is not the poster.
	"""
	deleteComment(input: DeleteCommentInput!): CommentParent!
	"""
	Post a new comment on a given object
	"""
	postComment(input: PostCommentInput!): CommentParent!
	"""
	Update a comment
	"""
	updateComment(comment: CommentUpdate!): CommentParent!
	"""
	Mutation for adding/changing contributor attributions
	"""
	updateContributorAttribution(contribution: UpdateContributorAttribution!): UUID!
	"""
	Mutation for deleting contributor attributions
	"""
	deleteContributorAttribution(contribution: DeleteContributorAttribution!): UUID!
	"""
	Mutation for paragraph and translation editing
	"""
	updateParagraph(paragraph: ParagraphUpdate!): DocumentParagraph!
	updatePage(data: JSON!): Boolean!
	updateAnnotation(data: JSON!): Boolean!
	updateWord(word: AnnotatedFormUpdate!): AnnotatedForm!
	"""
	Adds a bookmark to the user's list of bookmarks.
	"""
	addBookmark(documentId: UUID!): AnnotatedDoc!
	"""
	Removes a bookmark from a user's list of bookmarks
	"""
	removeBookmark(documentId: UUID!): AnnotatedDoc!
	"""
	Decide if a piece audio should be included in edited collection
	"""
	curateWordAudio(input: CurateWordAudioInput!): AnnotatedForm!
	"""
	Attach audio that has already been uploaded to S3 to a particular word
	Assumes user requesting mutation recoreded the audio
	"""
	attachAudioToWord(input: AttachAudioToWordInput!): AnnotatedForm!
	updateDocumentMetadata(document: DocumentMetadataUpdate!): UUID!
}

"""
A website page which lives at a specific URL and has a list of blocks that
define its content.
"""
type Page {
	"""
	The path that this page lives at, which also uniquely identifies it.
	For example, "/our-team"
	"""
	id: String!
	title: String!
	body: [ContentBlock!]!
}

type PageImage {
	"""
	The IIIF source this page image comes from
	"""
	source: ImageSource!
	"""
	The full IIIF url for this image resource
	"""
	url: String!
}

"""
A paragraph in an annotated document that can be edited.
"""
input ParagraphUpdate {
	"""
	Unique identifier of the form
	"""
	id: UUID!
	"""
	English translation of the paragraph
	"""
	translation: String
}

"""
The reference position within a document of one specific form
"""
type PositionInDocument {
	"""
	What document is this item within?
	"""
	documentId: UUID!
	"""
	What page is it on (starting from 1)? May be a single page or range of pages.
	"""
	pageNumber: String!
	"""
	How many items come before this one in the whole document?
	
	1-indexed position indicating where the form sits in the ordering of all
	forms in the document. Used for relative ordering of forms from the
	same document.
	"""
	index: Int!
	"""
	What section of the document image corresponds to this item?
	"""
	geometry: Geometry
	"""
	Standard page reference for this position, which can be used in citation.
	Generally formatted like ID:PAGE, i.e "DF2018:55"
	"""
	pageReference: String!
	"""
	Index reference for this position, more specific than `page_reference`.
	Generally used in corpus documents where there are few pages containing
	many forms each. Example: "WJ23:#21"
	"""
	indexReference: String!
	iiifUrl: String
}

"""
Input object for posting a new comment on some object
"""
input PostCommentInput {
	"""
	ID of the object that is being commented on
	"""
	parentId: UUID!
	"""
	Type of the object being commented on
	"""
	parentType: CommentParentType!
	"""
	Content of the comment
	"""
	textContent: String!
	"""
	A classifcation for the comment (optional)
	"""
	commentType: CommentType
}

type Query {
	allEditedCollections: [EditedCollection!]!
	editedCollection(slug: String!): EditedCollection
	"""
	Retrieves a chapter and its contents by its collection and chapter slug.
	"""
	chapter(collectionSlug: String!, chapterSlug: String!): CollectionChapter
	"""
	List of all the functional morpheme tags available
	"""
	allTags(system: CherokeeOrthography!): [MorphemeTag!]!
	"""
	Listing of all documents excluding their contents by default
	"""
	allDocuments: [AnnotatedDoc!]!
	"""
	List of all content pages
	"""
	allPages: [Page!]!
	"""
	List of all the document collections available.
	"""
	allCollections: [DocumentCollection!]!
	collection(slug: String!): DocumentCollection!
	"""
	Retrieves a full document from its unique name.
	"""
	document(slug: String!): AnnotatedDoc
	"""
	Retrieves all documents that are bookmarked by the current user.
	"""
	bookmarkedDocuments: [AnnotatedDoc!]!
	"""
	Retrieves a full document from its unique identifier.
	"""
	documentByUuid(id: UUID!): AnnotatedDoc
	"""
	Retrieves a full document from its unique identifier.
	"""
	page(id: String!): Page
	"""
	Lists all forms containing a morpheme with the given gloss.
	Groups these words by the phonemic shape of the target morpheme.
	"""
	morphemesByShape(gloss: String!, compareBy: CherokeeOrthography): [MorphemeReference!]!
	"""
	Lists all words containing a morpheme with the given gloss.
	Groups these words by the document containing them.
	"""
	morphemesByDocument(documentId: UUID, morphemeGloss: String!): [WordsInDocument!]!
	"""
	Forms containing the given morpheme gloss or related ones clustered over time.
	"""
	morphemeTimeClusters(gloss: String!, clusterYears: Int! = 10): [FormsInTime!]!
	"""
	Retrieve information for the morpheme that corresponds to the given tag
	string. For example, "3PL.B" is the standard string referring to a 3rd
	person plural prefix.
	"""
	morphemeTag(id: String!, system: CherokeeOrthography!): MorphemeTag
	"""
	Search for words that match any one of the given queries.
	Each query may match against multiple fields of a word.
	"""
	wordSearch(query: String!): [AnnotatedForm!]!
	"""
	Get a single word given the word ID
	"""
	wordById(id: UUID!): AnnotatedForm!
	"""
	Get a single paragraph given the paragraph ID
	"""
	paragraphById(id: UUID!): DocumentParagraph!
	"""
	Search for words with the exact same syllabary string, or with very
	similar looking characters.
	"""
	syllabarySearch(query: String!): [AnnotatedForm!]!
	"""
	Basic information about the currently authenticated user, if any.
	"""
	userInfo: UserInfo
}

"""
Attribution for a particular source, whether an institution or an individual.
Most commonly, this will represent the details of a library or archive that
houses documents used elsewhere.
"""
type SourceAttribution {
	"""
	Name of the source, i.e. "The Newberry Library"
	"""
	name: String!
	"""
	URL of this source's homepage, i.e. "https://www.newberry.org/"
	"""
	link: String!
}


"""
A UUID is a unique 128-bit number, stored as 16 octets. UUIDs are parsed as
Strings within GraphQL. UUIDs are used to assign unique identifiers to
entities without requiring a central allocating authority.

# References

* [Wikipedia: Universally Unique Identifier](http://en.wikipedia.org/wiki/Universally_unique_identifier)
* [RFC4122: A Universally Unique IDentifier (UUID) URN Namespace](http://tools.ietf.org/html/rfc4122)
"""
scalar UUID

"""
Update the contributor attribution for a document
"""
input UpdateContributorAttribution {
	documentId: UUID!
	contributorId: UUID!
	contributionRole: String!
}

"""
A user record, for a contributor, editor, etc.
"""
type User {
	"""
	Id of the user, which must be a AWS Cognito `sub` claim
	"""
	id: String!
	"""
	User-facing name for this contributor/curator
	"""
	displayName: String!
}

"""
A user belongs to any number of user groups, which give them various permissions.
"""
enum UserGroup {
	CONTRIBUTORS
	EDITORS
}

"""
Auth metadata on the user making the current request.
"""
type UserInfo {
	"""
	Unique ID for the User. Should be an AWS Cognito Sub.
	"""
	id: UUID!
	email: String!
	groups: [UserGroup!]!
}

type WordSegment {
	"""
	Phonemic representation of the morpheme
	"""
	morpheme: String!
	"""
	English gloss in standard DAILP format that refers to a lexical item
	"""
	gloss: String!
	"""
	What kind of thing is this segment?
	"""
	role: WordSegmentRole!
	"""
	This field determines what character should separate this segment from
	the previous one when reconstituting the full segmentation string.
	"""
	previousSeparator: String!
	"""
	If this morpheme represents a functional tag that we have further
	information on, this is the corresponding database entry.
	"""
	matchingTag: MorphemeTag
}

"""
The kind of segment that a particular sequence of characters in a morphemic
segmentations represent.
"""
enum WordSegmentRole {
	MORPHEME
	CLITIC
	MODIFIER
}

"""
A list of words grouped by the document that contains them.
"""
type WordsInDocument {
	"""
	Unique identifier of the containing document
	"""
	documentId: UUID
	"""
	What kind of document contains these words (e.g. manuscript vs dictionary)
	"""
	documentType: DocumentType
	"""
	List of annotated and potentially segmented forms
	"""
	forms: [AnnotatedForm!]!
}

schema {
	query: Query
	mutation: Mutation
}