# source: http://localhost:4000/api
# timestamp: Tue May 05 2020 17:26:14 GMT+0200 (heure d’été d’Europe centrale)

schema {
  query: RootQueryType
  mutation: RootMutationType
  subscription: RootSubscriptionType
}

"""
An action log
"""
type ActionLog {
  """
  The action that was done
  """
  action: ActionLogAction

  """
  The actor that acted
  """
  actor: Actor

  """
  Internal ID for this comment
  """
  id: ID

  """
  The time when the action was performed
  """
  insertedAt: DateTime

  """
  The object that was acted upon
  """
  object: ActionLogObject
}

enum ActionLogAction {
  COMMENT_DELETION
  EVENT_DELETION
  EVENT_UPDATE
  NOTE_CREATION
  NOTE_DELETION
  REPORT_UPDATE_CLOSED
  REPORT_UPDATE_OPENED
  REPORT_UPDATE_RESOLVED
}

"""
The objects that can be in an action log
"""
interface ActionLogObject {
  """
  Internal ID for this object
  """
  id: ID
}

"""
An ActivityPub actor
"""
interface Actor {
  """
  The actor's avatar picture
  """
  avatar: Picture

  """
  The actor's banner picture
  """
  banner: Picture

  """
  The actor's domain if (null if it's this instance)
  """
  domain: String

  """
  List of followers
  """
  followers: [Follower]

  """
  Number of followers for this actor
  """
  followersCount: Int

  """
  List of followings
  """
  following: [Follower]

  """
  Number of actors following this actor
  """
  followingCount: Int

  """
  Internal ID for this actor
  """
  id: ID

  """
  If the actor is from this instance
  """
  local: Boolean

  """
  Whether the actors manually approves followers
  """
  manuallyApprovesFollowers: Boolean

  """
  The actor's displayed name
  """
  name: String

  """
  The actor's preferred username
  """
  preferredUsername: String

  """
  The actor's summary
  """
  summary: String

  """
  If the actor is suspended
  """
  suspended: Boolean

  """
  The type of Actor (Person, Group,…)
  """
  type: ActorType

  """
  The ActivityPub actor's URL
  """
  url: String
}

"""
The list of types an actor can be
"""
enum ActorType {
  """
  An ActivityPub Application
  """
  APPLICATION

  """
  An ActivityPub Group
  """
  GROUP

  """
  An ActivityPub Organization
  """
  ORGANIZATION

  """
  An ActivityPub Person
  """
  PERSON

  """
  An ActivityPub Service
  """
  SERVICE
}

type Address {
  country: String
  description: String

  """
  The geocoordinates for the point where this address is
  """
  geom: Point
  id: ID

  """
  The address's locality
  """
  locality: String
  originId: String
  postalCode: String
  region: String

  """
  The address's street name (with number)
  """
  street: String
  type: String
  url: String
}

input AddressInput {
  country: String
  description: String

  """
  The geocoordinates for the point where this address is
  """
  geom: Point
  id: ID

  """
  The address's locality
  """
  locality: String
  originId: String
  postalCode: String
  region: String

  """
  The address's street name (with number)
  """
  street: String
  type: String
  url: String
}

type AdminSettings {
  instanceDescription: String
  instanceName: String
  instanceTerms: String
  instanceTermsType: InstanceTermsType
  instanceTermsUrl: String
  registrationsOpen: Boolean
}

type Anonymous {
  actorId: ID
  eventCreation: AnonymousEventCreation
  participation: AnonymousParticipation
}

type AnonymousEventCreation {
  allowed: Boolean
  validation: AnonymousEventCreationValidation
}

type AnonymousEventCreationValidation {
  captcha: AnonymousEventCreationValidationCaptcha
  email: AnonymousEventCreationValidationEmail
}

type AnonymousEventCreationValidationCaptcha {
  enabled: Boolean
}

type AnonymousEventCreationValidationEmail {
  confirmationRequired: Boolean
  enabled: Boolean
}

type AnonymousParticipation {
  allowed: Boolean
  validation: AnonymousParticipationValidation
}

type AnonymousParticipationValidation {
  captcha: AnonymousParticipationValidationCaptcha
  email: AnonymousParticipationValidationEmail
}

type AnonymousParticipationValidationCaptcha {
  enabled: Boolean
}

type AnonymousParticipationValidationEmail {
  confirmationRequired: Boolean
  enabled: Boolean
}

"""
Represents an application
"""
type Application implements Actor {
  """
  The actor's avatar picture
  """
  avatar: Picture

  """
  The actor's banner picture
  """
  banner: Picture

  """
  The actor's domain if (null if it's this instance)
  """
  domain: String

  """
  List of followers
  """
  followers: [Follower]

  """
  Number of followers for this actor
  """
  followersCount: Int

  """
  List of followings
  """
  following: [Follower]

  """
  Number of actors following this actor
  """
  followingCount: Int

  """
  Internal ID for this application
  """
  id: ID

  """
  If the actor is from this instance
  """
  local: Boolean

  """
  Whether the actors manually approves followers
  """
  manuallyApprovesFollowers: Boolean

  """
  The actor's displayed name
  """
  name: String

  """
  The actor's preferred username
  """
  preferredUsername: String

  """
  The actor's summary
  """
  summary: String

  """
  If the actor is suspended
  """
  suspended: Boolean

  """
  The type of Actor (Person, Group,…)
  """
  type: ActorType

  """
  The ActivityPub actor's URL
  """
  url: String
}

"""
A comment
"""
type Comment implements ActionLogObject {
  actor: Person
  deletedAt: DateTime
  event: Event

  """
  Internal ID for this comment
  """
  id: ID
  inReplyToComment: Comment
  insertedAt: DateTime
  local: Boolean
  originComment: Comment
  primaryLanguage: String
  replies: [Comment]
  text: String
  threadLanguages: [String]!
  totalReplies: Int
  updatedAt: DateTime
  url: String
  uuid: UUID
  visibility: CommentVisibility
}

"""
The list of visibility options for a comment
"""
enum CommentVisibility {
  """
  visible only to people invited
  """
  INVITE

  """
  Visible only after a moderator accepted
  """
  MODERATED

  """
  Visible only to people members of the group or followers of the person
  """
  PRIVATE

  """
  Publicly listed and federated. Can be shared.
  """
  PUBLIC

  """
  Visible only to people with the link - or invited
  """
  UNLISTED
}

"""
A config object
"""
type Config {
  anonymous: Anonymous
  countryCode: String
  demoMode: Boolean
  description: String
  geocoding: Geocoding
  location: Lonlat
  maps: Maps
  name: String
  registrationsOpen: Boolean
  registrationsWhitelist: Boolean
  resourceProviders: [ResourceProvider]

  """
  The instance's terms
  """
  terms(locale: String = "en"): Terms
}

"""
A discussion
"""
type discussion {
  actor: Actor

  """
  The comments for the discussion
  """
  comments(limit: Int = 10, page: Int = 1): PaginatedCommentList
  creator: Person

  """
  Internal ID for this discussion
  """
  id: ID
  insertedAt: DateTime
  lastComment: Comment
  slug: String
  title: String
  updatedAt: DateTime
}

type Dashboard {
  """
  Last public event publish
  """
  lastPublicEventPublished: Event

  """
  The number of local comments
  """
  numberOfComments: Int

  """
  The number of local events
  """
  numberOfEvents: Int

  """
  The number of current opened reports
  """
  numberOfReports: Int

  """
  The number of local users
  """
  numberOfUsers: Int
}

"""
The `DateTime` scalar type represents a date and time in the UTC
timezone. The DateTime appears in a JSON response as an ISO8601 formatted
string, including UTC timezone ("Z"). The parsed date and time string will
be converted to UTC and any UTC offset other than 0 will be rejected.
"""
scalar DateTime

"""
Represents a deleted feed_token
"""
type DeletedFeedToken {
  actor: DeletedObject
  user: DeletedObject
}

"""
Represents a deleted member
"""
type DeletedMember {
  actor: DeletedObject
  parent: DeletedObject
}

"""
A struct containing the id of the deleted object
"""
type DeletedObject {
  id: ID
}

"""
Represents a deleted participant
"""
type DeletedParticipant {
  actor: DeletedObject
  event: DeletedObject
  id: ID
}

"""
An event
"""
type Event implements ActionLogObject {
  """
  Who the event is attributed to (often a group)
  """
  attributedTo: Actor

  """
  Datetime for when the event begins
  """
  beginsOn: DateTime

  """
  The event's category
  """
  category: String

  """
  The comments in reply to the event
  """
  comments: [Comment]

  """
  When the event was created
  """
  createdAt: DateTime

  """
  The event's description
  """
  description: String

  """
  Whether or not the event is a draft
  """
  draft: Boolean

  """
  Datetime for when the event ends
  """
  endsOn: DateTime

  """
  Internal ID for this event
  """
  id: ID

  """
  The event's visibility
  """
  joinOptions: EventJoinOptions

  """
  Whether the event is local or not
  """
  local: Boolean

  """
  Online address of the event
  """
  onlineAddress: String

  """
  The event options
  """
  options: EventOptions

  """
  The event's organizer (as a person)
  """
  organizerActor: Actor
  participantStats: ParticipantStats

  """
  The event's participants
  """
  participants(
    actorId: ID
    limit: Int = 10
    page: Int = 1
    roles: String = ""
  ): PaginatedParticipantList

  """
  Phone address for the event
  """
  phoneAddress: String

  """
  The type of the event's address
  """
  physicalAddress: Address

  """
  The event's picture
  """
  picture: Picture

  """
  When the event was published
  """
  publishAt: DateTime

  """
  Events related to this one
  """
  relatedEvents: [Event]

  """
  The event's description's slug
  """
  slug: String

  """
  Status of the event
  """
  status: EventStatus

  """
  The event's tags
  """
  tags: [Tag]

  """
  The event's title
  """
  title: String

  """
  When the event was last updated
  """
  updatedAt: DateTime

  """
  The ActivityPub Event URL
  """
  url: String

  """
  The Event UUID
  """
  uuid: UUID

  """
  The event's visibility
  """
  visibility: EventVisibility
}

"""
The list of possible options for the event's status
"""
enum EventCommentModeration {
  """
  Anyone can comment under the event
  """
  ALLOW_ALL

  """
  No one can comment except for the admin
  """
  CLOSED

  """
  Every comment has to be moderated by the admin
  """
  MODERATED
}

"""
The list of join options for an event
"""
enum EventJoinOptions {
  """
  Anyone can join and is automatically accepted
  """
  FREE

  """
  Participants must be invited
  """
  INVITE

  """
  Manual acceptation
  """
  RESTRICTED
}

type EventOffer {
  """
  The price amount for this offer
  """
  price: Float

  """
  The currency for this price offer
  """
  priceCurrency: String

  """
  The URL to access to this offer
  """
  url: String
}

input EventOfferInput {
  """
  The price amount for this offer
  """
  price: Float

  """
  The currency for this price offer
  """
  priceCurrency: String

  """
  The URL to access to this offer
  """
  url: String
}

type EventOptions {
  """
  Whether or not to allow anonymous participation (if the server allows it)
  """
  anonymousParticipation: Boolean

  """
  The list of special attendees
  """
  attendees: [String]

  """
  The policy on public comment moderation under the event
  """
  commentModeration: EventCommentModeration

  """
  Whether to show or hide the person organizer when event is organized by a group
  """
  hideOrganizerWhenGroupEvent: Boolean

  """
  The maximum attendee capacity for this event
  """
  maximumAttendeeCapacity: Int

  """
  The list of offers to show for this event
  """
  offers: [EventOffer]

  """
  The list of participation conditions to accept to join this event
  """
  participationConditions: [EventParticipationCondition]

  """
  The list of the event
  """
  program: String

  """
  The number of remaining seats for this event
  """
  remainingAttendeeCapacity: Int

  """
  Show event end time
  """
  showEndTime: Boolean

  """
  Whether or not to show the participation price
  """
  showParticipationPrice: Boolean

  """
  Whether or not to show the number of remaining seats for this event
  """
  showRemainingAttendeeCapacity: Boolean

  """
  Show event start time
  """
  showStartTime: Boolean
}

input EventOptionsInput {
  """
  Whether or not to allow anonymous participation (if the server allows it)
  """
  anonymousParticipation: Boolean = false

  """
  The list of special attendees
  """
  attendees: [String]

  """
  The policy on public comment moderation under the event
  """
  commentModeration: EventCommentModeration

  """
  Whether to show or hide the person organizer when event is organized by a group
  """
  hideOrganizerWhenGroupEvent: Boolean

  """
  The maximum attendee capacity for this event
  """
  maximumAttendeeCapacity: Int

  """
  The list of offers to show for this event
  """
  offers: [EventOfferInput]

  """
  The list of participation conditions to accept to join this event
  """
  participationConditions: [EventParticipationConditionInput]

  """
  The list of the event
  """
  program: String

  """
  The number of remaining seats for this event
  """
  remainingAttendeeCapacity: Int

  """
  Show event end time
  """
  showEndTime: Boolean

  """
  Whether or not to show the participation price
  """
  showParticipationPrice: Boolean

  """
  Whether or not to show the number of remaining seats for this event
  """
  showRemainingAttendeeCapacity: Boolean

  """
  Show event start time
  """
  showStartTime: Boolean
}

type EventParticipationCondition {
  """
  The content for this condition
  """
  content: String

  """
  The title for this condition
  """
  title: String

  """
  The URL to access this condition
  """
  url: String
}

input EventParticipationConditionInput {
  """
  The content for this condition
  """
  content: String

  """
  The title for this condition
  """
  title: String

  """
  The URL to access this condition
  """
  url: String
}

"""
Search events result
"""
type Events {
  """
  Event elements
  """
  elements: [Event]!

  """
  Total elements
  """
  total: Int!
}

"""
The list of possible options for the event's status
"""
enum EventStatus {
  """
  The event is cancelled
  """
  CANCELLED

  """
  The event is confirmed
  """
  CONFIRMED

  """
  The event is tentative
  """
  TENTATIVE
}

"""
The list of visibility options for an event
"""
enum EventVisibility {
  """
  Visible only to people members of the group or followers of the person
  """
  PRIVATE

  """
  Publicly listed and federated. Can be shared.
  """
  PUBLIC

  """
  Visible only after a moderator accepted
  """
  RESTRICTED

  """
  Visible only to people with the link - or invited
  """
  UNLISTED
}

"""
Represents a participant to an event
"""
type FeedToken {
  """
  The event which the actor participates in
  """
  actor: Actor

  """
  The role of this actor at this event
  """
  token: String

  """
  The actor that participates to the event
  """
  user: User
}

"""
Represents an actor's follower
"""
type Follower {
  """
  Which profile follows
  """
  actor: Actor

  """
  Whether the follow has been approved by the target actor
  """
  approved: Boolean

  """
  When the follow was created
  """
  insertedAt: DateTime

  """
  What or who the profile follows
  """
  targetActor: Actor

  """
  When the follow was updated
  """
  updatedAt: DateTime
}

type Geocoding {
  autocomplete: Boolean
  provider: String
}

"""
Represents a group of actors
"""
type Group implements Actor {
  """
  The actor's avatar picture
  """
  avatar: Picture

  """
  The actor's banner picture
  """
  banner: Picture

  """
  A list of the discussions for this group
  """
  discussions: PaginatedDiscussionList

  """
  The actor's domain if (null if it's this instance)
  """
  domain: String

  """
  List of followers
  """
  followers: [Follower]

  """
  Number of followers for this actor
  """
  followersCount: Int

  """
  List of followings
  """
  following: [Follower]

  """
  Number of actors following this actor
  """
  followingCount: Int

  """
  Internal ID for this group
  """
  id: ID

  """
  If the actor is from this instance
  """
  local: Boolean

  """
  Whether the actors manually approves followers
  """
  manuallyApprovesFollowers: Boolean

  """
  List of group members
  """
  members: PaginatedMemberList

  """
  The actor's displayed name
  """
  name: String

  """
  Whether the group is opened to all or has restricted access
  """
  openness: Openness

  """
  A list of the events this actor has organized
  """
  organizedEvents: PaginatedEventList

  """
  The actor's preferred username
  """
  preferredUsername: String

  """
  A paginated list of the resources this group has
  """
  resources(limit: Int = 10, page: Int = 1): PaginatedResourceList

  """
  The actor's summary
  """
  summary: String

  """
  If the actor is suspended
  """
  suspended: Boolean

  """
  A paginated list of the todo lists this group has
  """
  todoLists: PaginatedTodoListList

  """
  The type of Actor (Person, Group,…)
  """
  type: ActorType

  """
  The type of group : Group, Community,…
  """
  types: GroupType

  """
  The ActivityPub actor's URL
  """
  url: String
}

"""
Search groups result
"""
type Groups {
  """
  Group elements
  """
  elements: [Group]!

  """
  Total elements
  """
  total: Int!
}

"""
The types of Group that exist
"""
enum GroupType {
  """
  A public group of many actors
  """
  COMMUNITY

  """
  A private group of persons
  """
  GROUP
}

enum InstanceTermsType {
  CUSTOM
  DEFAULT
  URL
}

"""
A JWT and the associated user ID
"""
type Login {
  """
  A JWT Token for this session
  """
  accessToken: String!

  """
  A JWT Token to refresh the access token
  """
  refreshToken: String!

  """
  The user associated to this session
  """
  user: User!
}

type Lonlat {
  accuracyRadius: Int
  latitude: Float
  longitude: Float
}

type Maps {
  tiles: Tiles
}

"""
Represents a member of a group
"""
type Member {
  """
  Which profile is member of
  """
  actor: Person

  """
  The member's ID
  """
  id: ID

  """
  Of which the profile is member
  """
  parent: Group

  """
  The role of this membership
  """
  role: MemberRoleEnum
}

enum MemberRoleEnum {
  ADMINISTRATOR
  CREATOR
  INVITED
  MEMBER
  MODERATOR
  NOT_APPROVED
  REJECTED
}

"""
The `Naive DateTime` scalar type represents a naive date and time without
timezone. The DateTime appears in a JSON response as an ISO8601 formatted
string.
"""
scalar NaiveDateTime

"""
Describes how an actor is opened to follows
"""
enum Openness {
  """
  The actor can only be followed by invitation
  """
  INVITE_ONLY

  """
  The actor needs to accept the following before it's effective
  """
  MODERATED

  """
  The actor is open to followings
  """
  OPEN
}

type PaginatedCommentList {
  """
  A list of comments
  """
  elements: [Comment]

  """
  The total number of comments in the list
  """
  total: Int
}

type PaginatedDiscussionList {
  """
  A list of discussion
  """
  elements: [discussion]

  """
  The total number of comments in the list
  """
  total: Int
}

type PaginatedEventList {
  """
  A list of events
  """
  elements: [Event]

  """
  The total number of events in the list
  """
  total: Int
}

type PaginatedFollowerList {
  """
  A list of followers
  """
  elements: [Follower]

  """
  The total number of elements in the list
  """
  total: Int
}

type PaginatedGroupList {
  """
  A list of groups
  """
  elements: [Group]

  """
  The total number of elements in the list
  """
  total: Int
}

type PaginatedMemberList {
  """
  A list of members
  """
  elements: [Member]

  """
  The total number of elements in the list
  """
  total: Int
}

type PaginatedParticipantList {
  """
  A list of participants
  """
  elements: [Participant]

  """
  The total number of participants in the list
  """
  total: Int
}

type PaginatedResourceList {
  """
  A list of resources
  """
  elements: [Resource]

  """
  The total number of resources in the list
  """
  total: Int
}

type PaginatedTodoList {
  """
  A list of todos
  """
  elements: [Todo]

  """
  The total number of todos in the list
  """
  total: Int
}

type PaginatedTodoListList {
  """
  A list of todo lists
  """
  elements: [TodoList]

  """
  The total number of todo lists in the list
  """
  total: Int
}

"""
Represents a participant to an event
"""
type Participant {
  """
  The actor that participates to the event
  """
  actor: Actor

  """
  The event which the actor participates in
  """
  event: Event

  """
  The participation ID
  """
  id: ID

  """
  The datetime this participant was created
  """
  insertedAt: DateTime

  """
  The metadata associated to this participant
  """
  metadata: ParticipantMetadata

  """
  The role of this actor at this event
  """
  role: ParticipantRoleEnum
}

type ParticipantMetadata {
  """
  The eventual token to leave an event when user is anonymous
  """
  cancellationToken: String

  """
  The eventual message the participant left
  """
  message: String
}

enum ParticipantRoleEnum {
  ADMINISTRATOR
  CREATOR
  MODERATOR
  NOT_APPROVED
  NOT_CONFIRMED
  PARTICIPANT
  REJECTED
}

type ParticipantStats {
  """
  The number of administrators
  """
  administrator: Int

  """
  The number of creators
  """
  creator: Int

  """
  The number of approved participants
  """
  going: Int

  """
  The number of moderators
  """
  moderator: Int

  """
  The number of not approved participants
  """
  notApproved: Int

  """
  The number of not confirmed participants
  """
  notConfirmed: Int

  """
  The number of simple participants (excluding creators)
  """
  participant: Int

  """
  The number of rejected participants
  """
  rejected: Int
}

"""
Represents a person identity
"""
type Person implements Actor {
  """
  The actor's avatar picture
  """
  avatar: Picture

  """
  The actor's banner picture
  """
  banner: Picture

  """
  The actor's domain if (null if it's this instance)
  """
  domain: String

  """
  A list of the feed tokens for this person
  """
  feedTokens: [FeedToken]

  """
  List of followers
  """
  followers: [Follower]

  """
  Number of followers for this actor
  """
  followersCount: Int

  """
  List of followings
  """
  following: [Follower]

  """
  Number of actors following this actor
  """
  followingCount: Int

  """
  Internal ID for this person
  """
  id: ID

  """
  If the actor is from this instance
  """
  local: Boolean

  """
  Whether the actors manually approves followers
  """
  manuallyApprovesFollowers: Boolean

  """
  The list of groups this person is member of
  """
  memberOf: [Member]

  """
  The list of group this person is member of
  """
  memberships: PaginatedMemberList

  """
  The actor's displayed name
  """
  name: String

  """
  A list of the events this actor has organized
  """
  organizedEvents: [Event]

  """
  The list of events this person goes to
  """
  participations(eventId: ID): [Participant]

  """
  The actor's preferred username
  """
  preferredUsername: String

  """
  The actor's summary
  """
  summary: String

  """
  If the actor is suspended
  """
  suspended: Boolean

  """
  The type of Actor (Person, Group,…)
  """
  type: ActorType

  """
  The ActivityPub actor's URL
  """
  url: String

  """
  The user this actor is associated to
  """
  user: User
}

"""
Search persons result
"""
type Persons {
  """
  Person elements
  """
  elements: [Person]!

  """
  Total elements
  """
  total: Int!
}

"""
A picture
"""
type Picture {
  """
  The picture's alternative text
  """
  alt: String

  """
  The picture's detected content type
  """
  contentType: String

  """
  The picture's ID
  """
  id: ID

  """
  The picture's name
  """
  name: String

  """
  The picture's size
  """
  size: Int

  """
  The picture's full URL
  """
  url: String
}

"""
An attached picture or a link to a picture
"""
input PictureInput {
  picture: PictureInputObject
  pictureId: ID
}

"""
An attached picture
"""
input PictureInputObject {
  actorId: ID
  alt: String
  file: Upload!
  name: String!
}

"""
The `Point` scalar type represents Point geographic information compliant string data,
represented as floats separated by a semi-colon. The geodetic system is WGS 84
"""
scalar Point

"""
Token
"""
type RefreshedToken {
  """
  Generated access token
  """
  accessToken: String!

  """
  Generated refreshed token
  """
  refreshToken: String!
}

"""
A report object
"""
type Report implements ActionLogObject {
  """
  The comments that are reported
  """
  comments: [Comment]

  """
  The comment the reporter added about this report
  """
  content: String

  """
  The event that is being reported
  """
  event: Event

  """
  The internal ID of the report
  """
  id: ID

  """
  When the report was created
  """
  insertedAt: DateTime

  """
  The notes made on the event
  """
  notes: [ReportNote]

  """
  The actor that is being reported
  """
  reported: Actor

  """
  The actor that created the report
  """
  reporter: Actor

  """
  Whether the report is still active
  """
  status: ReportStatus

  """
  When the report was updated
  """
  updatedAt: DateTime

  """
  The URI of the report
  """
  uri: String
}

"""
A report note object
"""
type ReportNote implements ActionLogObject {
  """
  The content of the note
  """
  content: String

  """
  The internal ID of the report note
  """
  id: ID

  """
  When the report note was created
  """
  insertedAt: DateTime

  """
  The moderator who added the note
  """
  moderator: Actor

  """
  The report on which this note is added
  """
  report: Report
}

"""
The list of possible statuses for a report object
"""
enum ReportStatus {
  """
  The report has been closed
  """
  CLOSED

  """
  The report has been opened
  """
  OPEN

  """
  The report has been marked as resolved
  """
  RESOLVED
}

"""
A resource
"""
type Resource {
  """
  The resource's owner
  """
  actor: Actor

  """
  Children resources in folder
  """
  children: PaginatedResourceList

  """
  The resource's creator
  """
  creator: Actor

  """
  The resource's ID
  """
  id: ID

  """
  The resource's creation date
  """
  insertedAt: NaiveDateTime

  """
  The resource's metadata
  """
  metadata: ResourceMetadata

  """
  The resource's parent
  """
  parent: Resource

  """
  The resource's path
  """
  path: String

  """
  The resource's URL
  """
  resourceUrl: String

  """
  The resource's summary
  """
  summary: String

  """
  The resource's title
  """
  title: String

  """
  The resource's type (if it's a folder)
  """
  type: String

  """
  The resource's last update date
  """
  updatedAt: NaiveDateTime

  """
  The resource's URL
  """
  url: String
}

type ResourceMetadata {
  authorName: String
  authorUrl: String

  """
  The resource's metadata description
  """
  description: String
  faviconUrl: String
  height: Int
  html: String

  """
  The resource's metadata image
  """
  imageRemoteUrl: String
  providerName: String
  providerUrl: String

  """
  The resource's metadata title
  """
  title: String

  """
  The type of the resource
  """
  type: String
  width: Int
}

type ResourceProvider {
  endpoint: String
  software: String
  type: String
}

type RootMutationType {
  """
  Create an user
  """
  createUser(email: String!, locale: String, password: String!): User

  """
  Register a first profile on registration
  """
  registerPerson(
    """
    The avatar for the profile, either as an object or directly the ID of an existing Picture
    """
    avatar: PictureInput

    """
    The banner for the profile, either as an object or directly the ID of an existing Picture
    """
    banner: PictureInput

    """
    The email from the user previously created
    """
    email: String!

    """
    The displayed name for the new profile
    """
    name: String = ""
    preferredUsername: String!

    """
    The summary for the new profile
    """
    summary: String = ""
  ): Person

  """
  Join a group
  """
  joinGroup(actorId: ID!, groupId: ID!): Member

  """
  Create a Feed Token
  """
  createFeedToken(actorId: ID): FeedToken

  """
  Get a preview for a resource link
  """
  previewResourceLink(resourceUrl: String!): ResourceMetadata

  """
  Create a note on a report
  """
  createReportNote(content: String, moderatorId: ID!, reportId: ID!): ReportNote

  """
  Create a discussion
  """
  createDiscussion(
    actorId: ID!
    creatorId: ID!
    text: String!
    title: String!
  ): discussion
  inviteMember(actorId: ID!, groupId: ID!, targetActorUsername: String!): Member

  """
  Leave an event
  """
  leaveEvent(actorId: ID!, eventId: ID!, token: String): DeletedParticipant

  """
  Login an user
  """
  login(email: String!, password: String!): Login

  """
  Change default actor for user
  """
  changeDefaultActor(preferredUsername: String!): User

  """
  Join an event
  """
  joinEvent(
    actorId: ID!
    email: String
    eventId: ID!
    message: String
  ): Participant

  """
  Create a todo
  """
  createTodo(
    assignedToId: ID
    dueDate: DateTime
    status: Boolean
    title: String!
    todoListId: ID!
  ): Todo

  """
  Change an user password
  """
  changePassword(newPassword: String!, oldPassword: String!): User

  """
  Create a new person for user
  """
  createPerson(
    """
    The avatar for the profile, either as an object or directly the ID of an existing Picture
    """
    avatar: PictureInput

    """
    The banner for the profile, either as an object or directly the ID of an existing Picture
    """
    banner: PictureInput

    """
    The displayed name for the new profile
    """
    name: String = ""
    preferredUsername: String!

    """
    The summary for the new profile
    """
    summary: String = ""
  ): Person
  replyToDiscussion(discussionId: ID!, text: String!): discussion

  """
  Resend registration confirmation token
  """
  resendConfirmationEmail(email: String!, locale: String): String

  """
  Create a todo list
  """
  createTodoList(groupId: ID!, title: String!): TodoList

  """
  Delete an event
  """
  deleteEvent(actorId: ID!, eventId: ID!): DeletedObject

  """
  Change an user email
  """
  changeEmail(email: String!, password: String!): User
  updateDiscussion(discussionId: ID!, title: String!): discussion

  """
  Create an event
  """
  createEvent(
    attributedToId: ID
    beginsOn: DateTime!
    category: String = "meeting"
    description: String!
    draft: Boolean = false
    endsOn: DateTime
    joinOptions: EventJoinOptions = FREE
    onlineAddress: String
    options: EventOptionsInput
    organizerActorId: ID!
    phoneAddress: String
    physicalAddress: AddressInput

    """
    The picture for the event, either as an object or directly the ID of an existing Picture
    """
    picture: PictureInput
    publishAt: DateTime
    status: EventStatus

    """
    The list of tags associated to the event
    """
    tags: [String] = [""]
    title: String!
    visibility: EventVisibility = PUBLIC
  ): Event

  """
  Delete a feed token
  """
  deleteFeedToken(token: String!): DeletedFeedToken

  """
  Delete a resource
  """
  deleteResource(id: ID!): DeletedObject

  """
  Reset user password
  """
  resetPassword(locale: String = "en", password: String!, token: String!): Login
  deleteReportNote(moderatorId: ID!, noteId: ID!): DeletedObject

  """
  Delete an identity
  """
  deletePerson(id: ID!): Person

  """
  Upload a picture
  """
  uploadPicture(
    actorId: ID!
    alt: String
    file: Upload!
    name: String!
  ): Picture

  """
  Refresh a token
  """
  refreshToken(refreshToken: String!): RefreshedToken

  """
  Delete a group
  """
  deleteGroup(actorId: ID!, groupId: ID!): DeletedObject

  """
  Update a resource
  """
  updateResource(
    actorId: ID
    id: ID!
    parentId: ID
    path: String
    resourceUrl: String
    summary: String
    title: String
  ): Resource

  """
  Create a comment
  """
  createComment(
    actorId: ID!
    eventId: ID
    inReplyToCommentId: ID
    text: String!
  ): Comment

  """
  Create a resource
  """
  createResource(
    actorId: ID!
    parentId: ID
    path: String! = "/"
    resourceUrl: String
    summary: String
    title: String
    type: String
  ): Resource

  """
  Update a report
  """
  updateReportStatus(
    moderatorId: ID!
    reportId: ID!
    status: ReportStatus!
  ): Report

  """
  Update an event
  """
  updateEvent(
    attributedToId: ID
    beginsOn: DateTime
    category: String
    description: String
    draft: Boolean
    endsOn: DateTime
    eventId: ID!
    joinOptions: EventJoinOptions = FREE
    onlineAddress: String
    options: EventOptionsInput
    organizerActorId: ID
    phoneAddress: String
    physicalAddress: AddressInput

    """
    The picture for the event, either as an object or directly the ID of an existing Picture
    """
    picture: PictureInput
    status: EventStatus

    """
    The list of tags associated to the event
    """
    tags: [String]
    title: String
    visibility: EventVisibility = PUBLIC
  ): Event

  """
  Confirm a participation
  """
  confirmParticipation(confirmationToken: String!): Participant
  deleteDiscussion(discussionId: ID!): discussion

  """
  Reject a relay subscription
  """
  rejectRelay(address: String!): Follower

  """
  Accept a participation
  """
  updateParticipation(
    id: ID!
    moderatorActorId: ID!
    role: ParticipantRoleEnum!
  ): Participant

  """
  Delete a todo
  """
  deleteTodo(id: ID!): DeletedObject
  deleteComment(actorId: ID!, commentId: ID!): Comment

  """
  Validate an user email
  """
  validateEmail(token: String!): User

  """
  Send a link through email to reset user password
  """
  sendResetPassword(email: String!, locale: String): String

  """
  Update a comment
  """
  updateComment(commentId: ID!, text: String!): Comment

  """
  Accept a relay subscription
  """
  acceptRelay(address: String!): Follower

  """
  Create a report
  """
  createReport(
    commentsIds: [ID] = [""]
    content: String
    eventId: ID
    forward: Boolean = false
    reportedId: ID!
    reporterId: ID!
  ): Report

  """
  Delete a relay subscription
  """
  removeRelay(address: String!): Follower

  """
  Update an identity
  """
  updatePerson(
    """
    The avatar for the profile, either as an object or directly the ID of an existing Picture
    """
    avatar: PictureInput

    """
    The banner for the profile, either as an object or directly the ID of an existing Picture
    """
    banner: PictureInput
    id: ID!

    """
    The displayed name for this profile
    """
    name: String

    """
    The summary for this profile
    """
    summary: String
  ): Person

  """
  Validate an user after registration
  """
  validateUser(token: String!): Login

  """
  Leave an event
  """
  leaveGroup(actorId: ID!, groupId: ID!): DeletedMember

  """
  Delete an account
  """
  deleteAccount(password: String!): DeletedObject

  """
  Create a group
  """
  createGroup(
    """
    The avatar for the group, either as an object or directly the ID of an existing Picture
    """
    avatar: PictureInput

    """
    The banner for the group, either as an object or directly the ID of an existing Picture
    """
    banner: PictureInput

    """
    The identity that creates the group
    """
    creatorActorId: ID!

    """
    The displayed name for the group
    """
    name: String

    """
    The name for the group
    """
    preferredUsername: String!

    """
    The summary for the group
    """
    summary: String = ""
  ): Group

  """
  Add a relay subscription
  """
  addRelay(address: String!): Follower
  saveAdminSettings(
    instanceDescription: String
    instanceName: String
    instanceTerms: String
    instanceTermsType: InstanceTermsType
    instanceTermsUrl: String
    registrationsOpen: Boolean
  ): AdminSettings

  """
  Update a todo
  """
  updateTodo(
    assignedToId: ID
    dueDate: DateTime
    id: ID!
    status: Boolean
    title: String
    todoListId: ID
  ): Todo
}

"""
Root Query
"""
type RootQueryType {
  """
  Get the list of action logs
  """
  actionLogs(limit: Int = 10, page: Int = 1): [ActionLog]
  adminSettings: AdminSettings

  """
  Get the instance config
  """
  config: Config

  """
  Get a discussion
  """
  discussion(id: ID!): discussion
  dashboard: Dashboard

  """
  Get an event by uuid
  """
  event(uuid: UUID!): Event

  """
  Get all events
  """
  events(limit: Int = 10, page: Int = 1): [Event]

  """
  Get a person by its (federated) username
  """
  fetchPerson(preferredUsername: String!): Person

  """
  Get a group by its preferred username
  """
  group(preferredUsername: String!): Group

  """
  Get all groups
  """
  groups(limit: Int = 10, page: Int = 1): PaginatedGroupList

  """
  Get the persons for an user
  """
  identities: [Person]

  """
  Get the current actor for the logged-in user
  """
  loggedPerson: Person

  """
  Get the current user
  """
  loggedUser: User

  """
  Get a person by its ID
  """
  person(id: ID!): Person

  """
  Get a picture
  """
  picture(id: String!): Picture
  relayFollowers(limit: Int = 10, page: Int = 1): PaginatedFollowerList
  relayFollowings(
    direction: String = "desc"
    limit: Int = 10
    orderBy: String = "updated_at"
    page: Int = 1
  ): PaginatedFollowerList

  """
  Get a report by id
  """
  report(id: ID!): Report

  """
  Get all reports
  """
  reports(limit: Int = 10, page: Int = 1, status: ReportStatus = OPEN): [Report]

  """
  Get a resource
  """
  resource(id: ID, path: String, username: String): Resource

  """
  Reverse geocode coordinates
  """
  reverseGeocode(
    latitude: Float!
    locale: String = "en"
    longitude: Float!
    zoom: Int = 15
  ): [Address]

  """
  Search for an address
  """
  searchAddress(
    limit: Int = 10
    locale: String = "en"
    page: Int = 1
    query: String!
  ): [Address]

  """
  Search events
  """
  searchEvents(limit: Int = 10, page: Int = 1, search: String!): Events

  """
  Search groups
  """
  searchGroups(limit: Int = 10, page: Int = 1, search: String!): Groups

  """
  Search persons
  """
  searchPersons(limit: Int = 10, page: Int = 1, search: String!): Persons

  """
  Get the list of tags
  """
  tags(limit: Int = 10, page: Int = 1): [Tag]!

  """
  Get replies for thread
  """
  thread(id: ID): [Comment]

  """
  Get a todo
  """
  todo(id: ID!): Todo

  """
  Get a todo list
  """
  todoList(id: ID!): TodoList

  """
  Get an user
  """
  user(id: ID!): User

  """
  List instance users
  """
  users(
    direction: SortDirection = DESC
    limit: Int = 10
    page: Int = 1
    sort: SortableUserField = ID
  ): Users
}

type RootSubscriptionType {
  eventPersonParticipationChanged(personId: ID!): Person
}

"""
The list of possible options for the event's status
"""
enum SortableUserField {
  ID
}

"""
Available sort directions
"""
enum SortDirection {
  ASC
  DESC
}

"""
A tag
"""
type Tag {
  """
  The tag's ID
  """
  id: ID

  """
  Related tags to this tag
  """
  related: [Tag]

  """
  The tags's slug
  """
  slug: String

  """
  The tag's title
  """
  title: String
}

type Terms {
  bodyHtml: String
  type: InstanceTermsType
  url: String
}

type Tiles {
  attribution: String
  endpoint: String
}

"""
A todo
"""
type Todo {
  """
  The todos's assigned person
  """
  assignedTo: Actor

  """
  The todo's creator
  """
  creator: Actor

  """
  The todo's due date
  """
  dueDate: DateTime

  """
  The todo's ID
  """
  id: ID

  """
  The todo's status
  """
  status: Boolean

  """
  The todo's title
  """
  title: String

  """
  The todo list this todo is attached to
  """
  todoList: TodoList
}

"""
A todo list
"""
type TodoList {
  """
  The actor that owns this todo list
  """
  actor: Actor

  """
  The todo list's ID
  """
  id: ID

  """
  The todo list's title
  """
  title: String

  """
  The todo-list's todos
  """
  todos: PaginatedTodoList
}

"""
Represents an uploaded file.
"""
scalar Upload

"""
A local user of Mobilizon
"""
type User {
  """
  The datetime the last activation/confirmation token was sent
  """
  confirmationSentAt: DateTime

  """
  The account activation/confirmation token
  """
  confirmationToken: String

  """
  The datetime when the user was confirmed/activated
  """
  confirmedAt: DateTime

  """
  The user's default actor
  """
  defaultActor: Person

  """
  The list of draft events this user has created
  """
  drafts(limit: Int = 10, page: Int = 1): [Event]

  """
  The user's email
  """
  email: String!

  """
  A list of the feed tokens for this user
  """
  feedTokens: [FeedToken]

  """
  The user's ID
  """
  id: ID!

  """
  The user's locale
  """
  locale: String

  """
  The list of memberships for this user
  """
  memberships(limit: Int = 10, page: Int = 1): PaginatedMemberList

  """
  The list of participations this user has
  """
  participations(
    afterDatetime: DateTime
    beforeDatetime: DateTime
    limit: Int = 10
    page: Int = 1
  ): [Participant]

  """
  The user's list of profiles (identities)
  """
  profiles: [Person]!

  """
  The datetime last reset password email was sent
  """
  resetPasswordSentAt: DateTime

  """
  The token sent when requesting password token
  """
  resetPasswordToken: String

  """
  The role for the user
  """
  role: UserRole
}

enum UserRole {
  ADMINISTRATOR
  MODERATOR
  USER
}

"""
Users list
"""
type Users {
  """
  User elements
  """
  elements: [User]!

  """
  Total elements
  """
  total: Int!
}

"""
The `UUID` scalar type represents UUID4 compliant string data, represented as UTF-8
character sequences. The UUID4 type is most often used to represent unique
human-readable ID strings.
"""
scalar UUID
