schema {
  query: Query
  mutation: Mutation
  subscription: Subscription
}

"""
Require a personal access token to have the given OAuth scope.
No-op for requests authenticated with a regular JWT.
"""
directive @scope(name: OAuthScopeEnum!) on FIELD_DEFINITION

directive @stream_HACK on FIELD

directive @defer on FRAGMENT_SPREAD

"""
A saved prompt submitted to an LLM (e.g. OpenAI) by a user. Stores the content sent and metadata about usage. Use to retrieve or display a user's AI prompt history.
"""
type AIPrompt {
  """The unique ID of this AI prompt record"""
  id: ID!
  """The ID of the user who created this prompt"""
  userId: ID!
  """the AI-generated title of the content"""
  title: String!
  """
  Plaintext of the content sent to the LLM. Does not include a preamble that includes formatting rules or type of data to expect
  """
  content: String!
  createdAt: DateTime!
  """The time the prompt was last used"""
  lastUsedAt: DateTime!
  """true if the prompt is owned by the user"""
  isUserDefined: Boolean!
}

"""
Return value for acceptRequestToJoinDomain mutation. Returns either an error or the updated viewer after a pending domain-join request has been approved by an org admin.
"""
union AcceptRequestToJoinDomainPayload = ErrorPayload | AcceptRequestToJoinDomainSuccess

"""
Successful result of acceptRequestToJoinDomain. The requesting user has been added to the organization that owns the verified email domain.
"""
type AcceptRequestToJoinDomainSuccess {
  """
  The current authenticated user, now a member of the organization that accepted their domain-join request
  """
  viewer: User!
}

"""
Return value for acceptTeamInvitation mutation. On success, contains a new auth token and the team the user joined. On failure, contains a StandardMutationError.
"""
type AcceptTeamInvitationPayload {
  error: StandardMutationError
  """
  A new JWT auth token issued after joining the team; the client should replace its current token with this one
  """
  authToken: ID
  """The ID of an in-progress meeting to redirect the user to after joining"""
  meetingId: ID
  """The in-progress meeting the user should be redirected to, if any"""
  meeting: NewMeeting
  """The team that the invitee joined"""
  team: Team
  """The new TeamMember record created for the user on the team"""
  teamMember: TeamMember
  """
  Any pending team-invitation notifications for the joining user that can now be dismissed
  """
  notifications: [NotificationTeamInvitation!]
  """
  The team lead user, updated with new suggested actions after a member joins
  """
  teamLead: User
}

"""
A Check-In meeting (also called an Action meeting). A structured team standup where members check in, review agenda items, and create or update tasks. Use to query details of a completed or in-progress Check-In meeting.
"""
type ActionMeeting implements NewMeeting {
  """
  The viewer's most recently generated AI inspiration items for a given integration service,
  cached for a short window. Empty if none have been generated recently.
  """
  inspirationItems(service: ServiceEnum!): [InspirationItem!]!
  """The unique meeting id. shortid."""
  id: ID!
  """The timestamp the meeting was created"""
  createdAt: DateTime!
  """
  The id of the user that created the meeting, null if user was hard deleted
  """
  createdBy: ID
  """The user that created the meeting, null if user was hard deleted"""
  createdByUser: User
  """The timestamp the meeting officially ended"""
  endedAt: DateTime
  """The location of the facilitator in the meeting"""
  facilitatorStageId: ID!
  """The userId (or anonymousId) of the most recent facilitator"""
  facilitatorUserId: ID!
  """The facilitator team member"""
  facilitator: TeamMember!
  """Is this locked for starter plans?"""
  locked: Boolean!
  """The team members that were active during the time of the meeting"""
  meetingMembers: [ActionMeetingMember!]!
  """The auto-incrementing meeting number for the team"""
  meetingNumber: Int!
  """The id of the meeting series this meeting belongs to"""
  meetingSeriesId: ID
  """
  The meeting series this meeting is associated with if the meeting is recurring
  """
  meetingSeries: MeetingSeries
  """Always ACTION for this meeting type"""
  meetingType: MeetingTypeEnum!
  """The name of the meeting"""
  name: String!
  """The organization this meeting belongs to"""
  organization: Organization!
  """
  The phases the meeting will go through, including all phase-specific state
  """
  phases: [NewMeetingPhase!]!
  """
  If meeting has a meeting series associated, this is the time the meeting will end
  """
  scheduledEndTime: DateTime
  """
  The OpenAI generated summary of all the content in the meeting, such as reflections, tasks, and comments. Undefined if the user doesnt have access to the feature or it's unavailable in this meeting type`
  """
  summary: String
  """The time the meeting summary was emailed to the team"""
  summarySentAt: DateTime
  """foreign key for team"""
  teamId: ID!
  """The team that ran the meeting"""
  team: Team!
  """The last time a meeting was updated (stage completed, finished, etc)"""
  updatedAt: DateTime
  """The action meeting member of the viewer"""
  viewerMeetingMember: ActionMeetingMember
  """A single agenda item"""
  agendaItem(agendaItemId: ID!): AgendaItem
  """The number of agenda items generated in the meeting"""
  agendaItemCount: Int!
  """All of the agenda items for the meeting"""
  agendaItems: [AgendaItem!]!
  """The number of comments generated in the meeting"""
  commentCount: Int!
  """The number of tasks generated in the meeting"""
  taskCount: Int!
  """The tasks created within the meeting"""
  tasks: [Task!]!
  """
  The ID of the publicly shareable summary page for this meeting, if one has been generated
  """
  summaryPageId: ID
}

"""
Represents a team member's participation record in a Check-In (Action) meeting. Tracks which tasks were completed or assigned during the meeting for that member.
"""
type ActionMeetingMember implements MeetingMember {
  """A composite of userId::meetingId"""
  id: ID!
  """true if present, false if absent, else null"""
  isCheckedIn: Boolean @deprecated(reason: "Members are checked in when they enter the meeting now & not created beforehand")
  """The ID of the meeting this member record belongs to"""
  meetingId: ID!
  """Always ACTION for this meeting type"""
  meetingType: MeetingTypeEnum!
  """The ID of the team this meeting belongs to"""
  teamId: ID!
  """The team member associated with this participation record"""
  teamMember: TeamMember!
  """The user associated with this participation record"""
  user: User!
  """The ID of the user associated with this participation record"""
  userId: ID!
  """The last time a meeting was updated (stage completed, finished, etc)"""
  updatedAt: DateTime!
  """The tasks marked as done in the meeting"""
  doneTasks: [Task!]!
  """The tasks assigned to members during the meeting"""
  tasks: [Task!]!
}

"""
Configuration settings for Check-In (Action) meetings on a team. Controls which phases are included in the meeting flow.
"""
type ActionMeetingSettings implements TeamMeetingSettings {
  """The unique ID of this settings record"""
  id: ID!
  """The type of meeting these settings apply to"""
  meetingType: MeetingTypeEnum!
  """The broad phase types that will be addressed during the meeting"""
  phaseTypes: [NewMeetingPhaseTypeEnum!]!
  """FK"""
  teamId: ID!
  """The team these settings belong to"""
  team: Team!
}

"""
Return value for addAgendaItem mutation. On success, contains the newly created agenda item and the updated meeting. On failure, contains a StandardMutationError.
"""
type AddAgendaItemPayload {
  error: StandardMutationError
  """The newly created agenda item"""
  agendaItem: AgendaItem
  """
  The ID of the meeting this agenda item was added to, if the item was added during an active meeting
  """
  meetingId: ID
  """The meeting with the updated agenda item, if any"""
  meeting: NewMeeting
}

"""
Return value for addApprovedOrganizationDomains mutation. Returns either an error or the updated organization after new email domains are approved for auto-join.
"""
union AddApprovedOrganizationDomainsPayload = ErrorPayload | AddApprovedOrganizationDomainsSuccess

"""
Successful result of addApprovedOrganizationDomains. The specified email domains have been added to the organization's approved list, allowing users with matching email addresses to auto-join.
"""
type AddApprovedOrganizationDomainsSuccess {
  """The ID of the organization whose approved domains were updated"""
  orgId: ID!
  """Organization with the updated approved domain list"""
  organization: Organization!
}

"""
Return value for addAtlassianAuth mutation. On success, contains the new Atlassian (Jira Cloud) integration and the updated team member. On failure, contains a StandardMutationError.
"""
type AddAtlassianAuthPayload {
  error: StandardMutationError
  """
  The newly created Atlassian (Jira Cloud) integration for the team member
  """
  atlassianIntegration: AtlassianIntegration
  """The ID of the team the Atlassian auth was connected to"""
  teamId: ID
  """The team member with the updated Atlassian auth"""
  teamMember: TeamMember
  """The user with the updated Atlassian auth"""
  user: User
}

input AddCommentInput {
  """A stringified TipTap JSONContent  document containing thoughts"""
  content: String!
  """true if the comment should be anonymous"""
  isAnonymous: Boolean
  """foreign key for the discussion this was created in"""
  discussionId: ID!
  """
  The sort order of this comment within its thread (used to order replies)
  """
  threadSortOrder: Int!
  """
  The ID of the parent comment if this is a reply; omit for top-level comments
  """
  threadParentId: ID
}

"""
Return value for addComment mutation. Returns either an error or the newly created comment along with the meeting it belongs to.
"""
union AddCommentPayload = ErrorPayload | AddCommentSuccess

"""
Successful result of addComment. The comment has been added to the specified discussion thread.
"""
type AddCommentSuccess {
  """The comment that was just created"""
  comment: Comment!
  """The ID of the meeting where the comment was added"""
  meetingId: ID!
}

"""
Return value for addGitHubAuth mutation. On success, contains the new GitHub integration and the updated team member. On failure, contains a StandardMutationError.
"""
type AddGitHubAuthPayload {
  error: StandardMutationError
  """The newly created GitHub integration for the team member"""
  githubIntegration: GitHubIntegration
  """The team member with the updated GitHub auth"""
  teamMember: TeamMember
  """The user with the updated GitHub auth"""
  user: User
}

"""An Integration Provider configuration"""
input AddIntegrationProviderInput {
  """
  The team that the token is linked to
  Must be provided if scope is 'team'
  """
  teamId: ID
  """
  The organization this provider is associated with
  Must be provided if scope is 'org'
  """
  orgId: ID
  """The service this provider is associated with"""
  service: IntegrationProviderServiceEnum!
  """The kind of token used by this provider"""
  authStrategy: IntegrationProviderAuthStrategyEnum!
  """
  The scope this provider configuration was created at (org-wide, or by the team)
  """
  scope: IntegrationProviderEditableScopeEnum!
  """
  Webhook provider metadata, has to be non-null if token type is webhook, refactor once we get https://github.com/graphql/graphql-spec/pull/825
  """
  webhookProviderMetadataInput: IntegrationProviderMetadataInputWebhook
  """
  OAuth1 provider metadata, has to be non-null if token type is OAuth1, refactor once we get https://github.com/graphql/graphql-spec/pull/825
  """
  oAuth1ProviderMetadataInput: IntegrationProviderMetadataInputOAuth1
  """
  OAuth2 provider metadata, has to be non-null if token type is OAuth2, refactor once we get https://github.com/graphql/graphql-spec/pull/825
  """
  oAuth2ProviderMetadataInput: IntegrationProviderMetadataInputOAuth2
  """
  Shared secret provider metadata, has to be non-null if token type is shared secret
  """
  sharedSecretMetadataInput: IntegrationProviderMetadataInputSharedSecret
}

"""
Return value for addIntegrationProvider mutation. Returns either an error or the newly registered integration provider configuration.
"""
union AddIntegrationProviderPayload = ErrorPayload | AddIntegrationProviderSuccess

"""
Successful result of addIntegrationProvider. The integration provider has been registered and is now available for use by teams or org members.
"""
type AddIntegrationProviderSuccess {
  """The newly registered integration provider"""
  provider: IntegrationProvider!
  """
  The updated set of organization-level integration providers, if the new provider affects org scope
  """
  orgIntegrationProviders: OrgIntegrationProviders
  """
  Updated team member integrations, if the new provider affects team scope
  """
  teamMemberIntegrations: TeamMemberIntegrations
}

"""
Return value for addNewFeature mutation. Contains the new feature broadcast that was announced to all users.
"""
type AddNewFeaturePayload {
  """The new feature announcement broadcast to all users"""
  newFeature: NewFeatureBroadcast
}

"""
Subscription payload sent when a new notification is created for the current user. Use this to update the client's notification list in real time.
"""
type AddNotificationPayload {
  """The newly created notification for the current user"""
  notification: Notification
}

"""
Discriminates between adding and removing an item in a collection. Used as the
action field on mutation inputs (e.g. UpdatePokerScopeItemInput) where a single
mutation handles both insert and removal rather than exposing separate add/remove
mutations.
"""
enum AddOrDeleteEnum {
  """
  Insert the item into the collection. Use this when the item does not yet
  exist in the target set and should be added (e.g. adding a task to the
  scope of a sprint poker meeting).
  """
  ADD
  """
  Remove the item from the collection. Use this when the item already exists
  in the target set and should be removed (e.g. removing a task from the
  scope of a sprint poker meeting).
  """
  DELETE
}

"""
Payload returned after the addOrg mutation, which creates a new organization with an initial team and adds the caller as the team leader.
"""
type AddOrgPayload {
  """The newly created organization."""
  organization: Organization
  error: StandardMutationError
  """
  The first team created inside the new organization. Every new org starts with exactly one team.
  """
  team: Team
  """
  The TeamMember record for the caller, who is automatically added as the leader of the new team.
  """
  teamMember: TeamMember
  """
  The ID of the 'Create a New Team' suggested action that was removed from the caller's dashboard as a result of this mutation. Null if no such suggestion existed.
  """
  removedSuggestedActionId: ID
}

"""
The payload returned after adding a new dimension to a poker template.
A dimension represents a scoring axis (e.g., effort, complexity, business value) that participants
estimate during a Sprint Poker meeting. On success, the new dimension is appended to the template
and broadcast to all team members via the TEAM subscription channel.
"""
type AddPokerTemplateDimensionPayload {
  """
  Present when the mutation fails (e.g., template not found, dimension limit reached).
  Null on success.
  """
  error: StandardMutationError
  """The newly created dimension. Null when an error occurred."""
  dimension: TemplateDimension
}

"""
The result of the addPokerTemplate mutation, which creates a new Sprint Poker template for a team.
A template can be created from scratch (with a single default dimension) or cloned from an existing
template (copies all dimensions from the parent). Returns either a success object containing the
new template and the creating user, or an ErrorPayload if the operation failed (e.g. the team was
not found, the user has exhausted their free custom template allowance on the starter tier, or the
parent template is not accessible to the viewer).
"""
union AddPokerTemplatePayload = ErrorPayload | AddPokerTemplateSuccess

"""
The payload returned by the addPokerTemplateScale mutation. On success, returns the newly created TemplateScale. If parentScaleId was provided, the new scale is a copy of that parent scale; otherwise a blank scale is created for the team.
"""
type AddPokerTemplateScalePayload {
  """Present when the mutation fails. Null on success."""
  error: StandardMutationError
  """
  The newly created scale, ready to be named and populated with values. Null if the mutation failed.
  """
  scale: TemplateScale
}

"""
The result of the addPokerTemplateScaleValue mutation, which adds a new value
(e.g., a story-point label like "XS" or "?") to an existing poker template scale.
On success, the updated scale — including its full list of values — is returned.
On failure, error is populated and scale is null.
"""
type AddPokerTemplateScaleValuePayload {
  """
  Present when the mutation fails; describes what went wrong. Null on success.
  """
  error: StandardMutationError
  """
  The poker template scale that was modified, now containing the newly added value.
  Use this to update the client-side scale and its values list without a separate refetch.
  Null when an error occurred.
  """
  scale: TemplateScale
}

"""
Returned when the addPokerTemplate mutation succeeds. Contains the newly created (or cloned) poker
template and the user who triggered the operation. Use this to update the client's template list and
reflect the creator's identity without a separate query.
"""
type AddPokerTemplateSuccess {
  """The poker template that was created"""
  pokerTemplate: PokerTemplate!
  """The user that created the template"""
  user: User!
}

"""
The result of the addReactjiToReactable mutation, which adds or removes an emoji reaction on a reactable item (such as a reflection or comment). Returns the updated reactable on success, or an error if the operation failed (e.g. item not found, user lacks permission).
"""
union AddReactjiToReactablePayload = AddReactjiToReactableSuccess | ErrorPayload

"""
Returned when an emoji reaction (reactji) has been successfully added to a reactable item
(a comment, reflection, or response). Use the reactable field to read the updated list of
reactjis and re-render the reaction bar on the item.
"""
type AddReactjiToReactableSuccess {
  """
  The item that received the reactji, with its reactjis list updated to include the new reaction.
  Cast to the concrete type (Comment, RetroReflection, or Poll Response) to access type-specific fields.
  """
  reactable: Reactable!
}

"""
Result of the addReflectTemplate mutation, which creates a new retrospective meeting template for a team (optionally cloned from an existing template via parentTemplateId). Returns AddReflectTemplateSuccess on success, or ErrorPayload if the operation fails (e.g. insufficient permissions, invalid team, or template limit reached).
"""
union AddReflectTemplatePayload = ErrorPayload | AddReflectTemplateSuccess

"""
Returned by the addReflectTemplatePrompt mutation. On success, contains the newly created
ReflectPrompt that was appended to the specified retrospective template. On failure, contains
a StandardMutationError describing what went wrong (e.g. template not found, insufficient
permissions, or the template already has the maximum number of prompts).
"""
type AddReflectTemplatePromptPayload {
  error: StandardMutationError
  """
  The newly created prompt added to the retrospective template. Null when the mutation fails.
  Use this to update the UI with the new prompt, including its generated id, default question
  text, description, groupColor, and sort order within the template.
  """
  prompt: ReflectPrompt
}

"""
Returned when the addReflectTemplate mutation succeeds. This payload is produced in two scenarios:
(1) a brand-new blank reflect (retrospective) template is created for a team, seeded with a single
default prompt; or (2) an existing template is cloned — when parentTemplateId is provided the new
template is named "<original> Copy" (or "<original> Copy #N" for subsequent clones) and all of the
source template's active prompts are duplicated. In both cases the caller's
freeCustomRetroTemplatesRemaining counter is decremented if the team is on the starter tier.
Use the reflectTemplate field to read the created/cloned template immediately and the user field
to update any client-side state that tracks the viewer's remaining free template quota.
"""
type AddReflectTemplateSuccess {
  """
  The newly created or cloned reflect template. For a net-new template this will contain a single
  default prompt named "New prompt". For a clone it will contain copies of every active prompt from
  the source template. Use this to update the team's template list in the client cache.
  """
  reflectTemplate: ReflectTemplate!
  """
  The viewer (authenticated user) who performed the mutation. Returned so the client can refresh
  freeCustomRetroTemplatesRemaining, which is decremented on starter-tier teams each time a custom
  template is created or cloned.
  """
  user: User!
}

"""
Payload returned after a user completes the Slack OAuth flow to connect their Slack account to a Parabol team. On success, slackIntegration and user are populated; on failure, error is populated and the other fields are null.
"""
type AddSlackAuthPayload {
  """
  Present when the mutation failed. Contains a human-readable message and an error code describing why the Slack auth could not be added.
  """
  error: StandardMutationError
  """
  The newly created or updated Slack integration record, linking the Parabol team member to their Slack workspace. Use this to read the resulting bot credentials, default notification channel, and per-event notification settings.
  """
  slackIntegration: SlackIntegration
  """
  The Parabol user whose Slack auth was just added or refreshed. Use this to reflect updated integration state in the UI without a separate user query.
  """
  user: User
}

"""
The result of the addTeamMemberIntegrationAuth mutation, which links an integration provider's
credentials (OAuth2 token, OAuth1 token, personal access token, or webhook URL) to a specific
team member. Returns the updated auth record and related entities on success, or an error if
the authorization could not be stored (e.g. invalid code, provider not found, permission denied).
"""
union AddTeamMemberIntegrationAuthPayload = ErrorPayload | AddTeamMemberIntegrationAuthSuccess

"""
The success payload returned when a team member's integration auth credentials are successfully
added or replaced via the addTeamMemberIntegrationAuth mutation. This payload is returned after
a user completes an OAuth flow (OAuth1, OAuth2) or provides a personal access token (PAT),
and the resulting credentials have been persisted and linked to their account on a specific team.
"""
type AddTeamMemberIntegrationAuthSuccess {
  """
  The newly created or updated auth credential record that was upserted for this team member.
  Contains the access token, refresh token, and related metadata for the integration service.
  """
  integrationAuth: TeamMemberIntegrationAuth!
  """
  The integration service (e.g. github, gitlab, jira, linear) that the newly added auth
  credential is associated with. Denormalized from the integration provider for convenience.
  """
  service: IntegrationProviderServiceEnum!
  """
  The team member record (user + team relationship) whose integration auth was just updated.
  Useful for refreshing the client-side view of which integrations are connected for this person
  on this team.
  """
  teamMember: TeamMember!
  """
  The user who completed the auth flow and whose credentials were saved. This is always the
  currently authenticated viewer — a user can only add auth for themselves.
  """
  user: User!
}

"""
Return payload for the addTeam mutation. Returned when a user creates a new team within an existing organization. Contains the new team, the creator's team membership record, and an optional side-effect indicating that a suggested-action prompt has been dismissed.
"""
type AddTeamPayload {
  """
  Non-null if the mutation failed. Contains an error name and message describing what went wrong.
  """
  error: StandardMutationError
  """The newly created team."""
  team: Team
  """
  The TeamMember record for the user who created the team. Use this to update the viewer's team list and permissions in the client.
  """
  teamMember: TeamMember
  """
  The ID of the 'createNewTeam' suggested action that was automatically dismissed because the user fulfilled it by creating a team. Null if no such suggestion existed. Use this to remove the suggestion from the client UI.
  """
  removedSuggestedActionId: ID
}

"""
Input for adding a new value to an existing poker template scale. Used with the addPokerTemplateScaleValue mutation, which appends a single TemplateScaleValue to the ordered list of values on a TemplateScale. Each scale value represents one option that participants can vote on during a Poker meeting (e.g., a story-point size or complexity tier).
"""
input AddTemplateScaleInput {
  """
  The hex color code (e.g., "#DB70DB") used to visually distinguish this scale value from others on the scale. Colors are displayed in the Poker voting UI next to the label so participants can quickly identify each option.
  """
  color: String!
  """
  A short human-readable label for this scale value shown to participants during voting (e.g., "XS", "M", "L", "1", "8", "?"). Labels must be unique within the scale.
  """
  label: String!
}

"""
The result of the addTranscriptionBot mutation, which attaches a Recall.ai transcription bot to an active Zoom video meeting linked to a retrospective. On success, returns AddTranscriptionBotSuccess containing the updated meeting (with the videoMeetingURL and recallBotId populated). On failure, returns ErrorPayload describing what went wrong (e.g. meeting not found, meeting type is not retrospective).
"""
union AddTranscriptionBotPayload = ErrorPayload | AddTranscriptionBotSuccess

"""
Returned when addTranscriptionBot succeeds. Confirms that a Recall.ai bot has
been dispatched to the video call identified by videoMeetingURL and that the
retrospective meeting record has been updated with that URL. The bot will
join the call, capture a transcript, and store it on the meeting once the
call ends. Use the returned meeting to read the updated videoMeetingURL and,
after the call concludes, the transcription field.
"""
type AddTranscriptionBotSuccess {
  """
  The retrospective meeting that was updated with the video meeting URL and
  the Recall.ai bot assignment. Query videoMeetingURL to confirm the URL that
  was stored, or transcription to retrieve the transcript once the bot has
  finished processing the recording.
  """
  meeting: RetrospectiveMeeting!
}

"""
Subscription payload delivered when a new Notification is created for the current viewer.
Returned as the AddedNotification field on NotificationSubscriptionPayload whenever the
server pushes a freshly-created notification to the client (e.g. a team invitation arrives,
a meeting stage time limit fires, or a payment fails). Use this to insert the notification
into the client-side notification list without requiring a full refetch.
"""
type AddedNotification {
  """
  The newly created notification that was just sent to the viewer. Query its type field
  to determine which concrete Notification implementation was returned and render the
  appropriate UI (e.g. NotificationTeamInvitation, NotificationMeetingStageTimeLimitEnd).
  """
  addedNotification: Notification!
}

"""
A topic a team member wants to discuss during the agenda phase of a Check-In meeting (meetingType: "action"). Agenda items are added before or during a meeting, worked through one-by-one in the AgendaItemsPhase, and cleared when the meeting ends. Items marked as pinned are automatically re-created for the next meeting so recurring topics always appear on the agenda.
"""
type AgendaItem {
  """The unique agenda item id, formatted as teamId::shortid"""
  id: ID!
  """The text description of the topic to discuss. Maximum 64 characters."""
  content: String!
  """The timestamp the agenda item was created"""
  createdAt: DateTime
  """
  True if the agenda item is currently visible and actionable. Set to false when the item is removed or when the meeting ends and non-pinned items are cleared.
  """
  isActive: Boolean!
  """
  The id of the Check-In meeting this agenda item belongs to. Null when the item was added outside of a meeting or carried forward from a previous meeting via pinning.
  """
  meetingId: ID
  """
  True if this agenda item should automatically be re-added to the next meeting when the current meeting ends. Pinned items are cloned at meeting close so they persist across meetings.
  """
  pinned: Boolean
  """
  The id of the original agenda item that was first pinned, tracing the clone lineage across meetings. Null on the original pinned item itself; set on every subsequent clone so the full history of a recurring topic can be retrieved.
  """
  pinnedParentId: ID
  """
  The fractional-index sort order used to position this item in the agenda list
  """
  sortOrder: String!
  """The id of the team this agenda item belongs to"""
  teamId: ID!
  """The team member who created this agenda item"""
  teamMember: TeamMember!
  """The id of the team member who created this agenda item"""
  teamMemberId: ID!
  """The timestamp the agenda item was last updated"""
  updatedAt: DateTime
}

"""
The phase of an Action meeting in which the team works through each agenda item one by one.
Each agenda item gets its own AgendaItemsStage, and the team discusses them in order.
This phase only appears in Action meetings (not retrospectives or poker meetings).
Use this type when traversing meeting phases to find agenda-item discussion stages,
or when you need to know which team's meeting a set of agenda items belongs to.
"""
type AgendaItemsPhase implements NewMeetingPhase {
  """Unique identifier for this phase instance (shortid format)"""
  id: ID!
  """The ID of the Action meeting this phase belongs to"""
  meetingId: ID!
  """The ID of the team running this meeting"""
  teamId: ID!
  """The type of phase — always 'agendaitems' for this type"""
  phaseType: NewMeetingPhaseTypeEnum!
  """
  Ordered list of stages, one per agenda item. Each stage represents the discussion
  of a single agenda item. Navigate through these stages to find or display each
  agenda item's discussion thread.
  """
  stages: [AgendaItemsStage!]!
}

"""The stage where the team discusses a single agenda item"""
type AgendaItemsStage implements NewMeetingStage & DiscussionThreadStage {
  """stageId, shortid"""
  id: ID!
  """The datetime the stage was completed"""
  endAt: DateTime
  """foreign key. try using meeting"""
  meetingId: ID!
  """The meeting this stage belongs to"""
  meeting: NewMeeting!
  """
  true if the facilitator has completed this stage, else false. Should be boolean(endAt)
  """
  isComplete: Boolean!
  """true if any meeting participant can navigate to this stage"""
  isNavigable: Boolean!
  """true if the facilitator can navigate to this stage"""
  isNavigableByFacilitator: Boolean!
  """The phase this stage belongs to"""
  phase: NewMeetingPhase
  """The type of the phase"""
  phaseType: NewMeetingPhaseTypeEnum
  """The datetime the stage was started"""
  startAt: DateTime
  """Number of times the facilitator has visited this stage"""
  viewCount: Int
  """
  true if a time limit is set, false if end time is set, null if neither is set
  """
  isAsync: Boolean
  """true if the viewer is ready to advance, else false"""
  isViewerReady: Boolean!
  """User ids of those who are ready to advance to the next stage"""
  readyUserIds: [ID!]!
  """
  The datetime the phase is scheduled to be finished, null if no time limit or end time is set
  """
  scheduledEndTime: DateTime
  """
  The suggested ending datetime for a phase to be completed async, null if not enough data to make a suggestion
  """
  suggestedEndTime: DateTime
  """
  The suggested time limit for a phase to be completed together, null if not enough data to make a suggestion
  """
  suggestedTimeLimit: Float
  """The team hosting the meeting this stage belongs to"""
  teamId: ID!
  """
  The number of milliseconds left before the scheduled end time. Useful for unsynced client clocks. null if scheduledEndTime is null
  """
  timeRemaining: Float
  """
  The 0-based position of this stage within its phase, ordered by sortOrder.
  """
  stageIdx: Int!
  """The ID to find the discussion that goes in the stage"""
  discussionId: ID!
  """The discussion about the stage"""
  discussion: Discussion!
  """The id of the agenda item this relates to"""
  agendaItemId: ID!
  """
  The agenda item being discussed in this stage. Contains the topic text, who added it, and whether it has been pinned for recurring use
  """
  agendaItem: AgendaItem!
}

"""
Payload returned after archiving an organization. Archiving permanently deactivates the org and all its teams. Only starter-tier orgs can be archived — paid orgs must be downgraded first. On success, all teams are archived, all org memberships are soft-deleted, and suggested actions tied to those teams are removed.
"""
type ArchiveOrganizationPayload {
  error: StandardMutationError
  """
  The ID of the organization that was archived. Use this to remove the org from the client store.
  """
  orgId: ID
  """
  All teams that belonged to the organization and were archived as part of this operation. Use this to update team records in the client store.
  """
  teams: [Team!]
  """
  IDs of suggested actions that were removed because the teams they referenced no longer exist. Use this to purge stale suggested actions from the client store.
  """
  removedSuggestedActionIds: [ID]
}

"""
The action to perform on a page via the archivePage mutation. Pages follow a
soft-delete lifecycle: they are first moved to the trash (archive), and can
then be permanently removed (delete) or recovered (restore). Use `archive` for
the initial move-to-trash step, `delete` only when the page is already in the
trash and permanent removal is intended, and `restore` to undo a previous
archive.
"""
enum ArchivePageActionEnum {
  """
  Move the page to the trash. The page is soft-deleted and hidden from normal
  views but can still be restored. This is the first step in the delete
  lifecycle.
  """
  archive
  """
  Permanently delete the page from the trash. The page must already be in the
  trash (i.e., previously archived). This action is irreversible.
  """
  delete
  """
  Restore the page from the trash back to its original location. The page must
  currently be in the trash (i.e., previously archived but not yet permanently
  deleted).
  """
  restore
}

"""
The return payload for the archivePage mutation, which handles all three steps
of a page's soft-delete lifecycle: moving to trash (archive), permanent removal
(delete), and recovery (restore). Check pageId to confirm which page was acted
on, and inspect page (or its absence) to determine the resulting state.
"""
type ArchivePagePayload {
  """
  The ID of the page that was acted on. Always present so callers can update
  local state even when the page object itself is no longer accessible.
  """
  pageId: String
  """
  The affected page after the action was applied. Null when the page was
  permanently deleted (hard-deleted), because no record remains to return.
  Present after an archive (soft-delete) or restore action, allowing the
  caller to read the updated deletedAt and other fields.
  """
  page: Page
}

"""
Return value for the archiveTeam mutation. When a team is archived (or deleted if unused),
this payload delivers the updated team record, a notification sent to all former members,
the IDs of any homepage suggested-action cards that were removed, and the IDs of meeting
templates owned by the team so clients can remove them from local caches.
"""
type ArchiveTeamPayload {
  error: StandardMutationError
  """
  The team that was archived (or deleted). Inspect team.isArchived to distinguish the two cases.
  Null when the operation fails.
  """
  team: Team
  """
  A notification explaining that the team was archived and removed from view
  """
  notification: NotifyTeamArchived
  """
  IDs of suggested-action cards (e.g. "Invite your team", "Try a retro") that were shown on the
  user's homepage and are now removed because they referenced this team. Clients should evict
  these records from their caches.
  """
  removedSuggestedActionIds: [ID]
  """A list of the ids of templates created by a team"""
  teamTemplateIds: [ID!]!
}

"""
The result of the archiveTimelineEvent mutation, which hides a timeline event from the user's activity feed. Returns either a success object containing the updated event or an error if the event could not be found or the caller lacks permission to archive it.
"""
union ArchiveTimelineEventPayload = ErrorPayload | ArchiveTimelineEventSuccess

"""
Returned when the archiveTimelineEvent mutation succeeds. Archiving a timeline
event sets its isActive flag to false, hiding it from the viewer's activity
feed without permanently deleting it. Use this payload to update local state
so the event is removed from the displayed timeline.
"""
type ArchiveTimelineEventSuccess {
  """
  The timeline event that was just archived. Its isActive field will be false.
  Use this to remove or hide the event in the caller's UI after a successful mutation.
  """
  timelineEvent: TimelineEvent!
}

"""
The area of the application UI from which a task mutation (createTask, updateTask) was triggered.
Used for analytics and context tracking so the server knows which view the user was in when they
created or modified a task.
"""
enum AreaEnum {
  """
  The user was inside an active meeting (e.g. Action, Retrospective, Poker) when the task was
  created or updated. Use this value when the task card is rendered within a meeting room.
  """
  meeting
  """
  The user was on the Team Dashboard (the per-team task board at /team/:teamId/tasks) when the
  task was created or updated. Use this value when the task card is rendered in the team task
  columns view.
  """
  teamDash
  """
  The user was on their personal My Dashboard (the cross-team task view at /me/tasks) when the
  task was created or updated. Use this value when the task card is rendered in the user-scoped
  task columns view.
  """
  userDash
}

"""
Controls who can read an uploaded asset. The scope is encoded into the asset's storage path
(e.g. Team/<teamId>/assets/<hash>.webp) and is enforced at both upload time and serve time.
Choose the narrowest scope that satisfies the use-case so that assets are not inadvertently
exposed to unrelated users.
"""
enum AssetScopeEnum {
  """
  Asset is tied to a single Page (a collaborative document). Any user with at least viewer
  access to that page can read the asset. The scopeKey must be the page's client-side
  cipher ID, and the uploader must hold commentor or higher access to the page.
  Use this scope for files or images embedded inside a specific page.
  """
  Page
  """
  Asset is private to a single user. Only the owning user (or the ghost user) can read
  non-avatar assets stored under this scope. Profile pictures (assetType = "picture") are
  an exception and are visible to all authenticated users.
  The scopeKey must equal the caller's own userId.
  Use this scope for personal uploads that should not be visible to teammates.
  """
  User
  """
  Asset is shared within a team. Any team member can read non-avatar assets stored under
  this scope. Team avatars (assetType = "picture", not yet implemented) are visible to all
  users. The scopeKey must be a teamId that the caller belongs to.
  Use this scope for files uploaded in the context of a team meeting or team workspace.
  """
  Team
  """
  Asset is shared within an organization. Any member of the organization can read
  non-avatar assets stored under this scope. Org avatars (assetType = "picture") and IdP
  metadata files are publicly readable. Parabol-seeded assets live under the special
  "aGhostOrg" org and are visible to all users.
  The scopeKey must be an orgId that the caller belongs to.
  Use this scope for org-wide resources such as template illustrations or branding assets.
  """
  Organization
}

"""
The Atlassian (Jira Cloud) OAuth integration for a specific user on a specific Parabol team.
Stores the OAuth tokens and account linkage needed to read and write Jira issues on behalf of
the user. One record exists per (team, user) pair. Use this type to determine whether a team
member has connected Jira, to retrieve their accessible Jira projects, and to fetch or search
Jira issues for display in Parabol meetings (e.g. Sprint Poker estimation).
"""
type AtlassianIntegration {
  """
  Composite primary key in the format "atlassian:teamId:userId". Use this to uniquely
  identify a single user's Atlassian integration within a specific Parabol team.
  """
  id: ID!
  """
  Whether the stored OAuth tokens are still valid and the integration is usable. Becomes
  false when the user revokes access in Atlassian, the refresh token expires, or the
  integration is explicitly disconnected. Check this before attempting any Jira operations.
  """
  isActive: Boolean!
  """
  A short-lived Atlassian OAuth 2.0 access token (valid for ~1 hour) that can be used to
  call the Atlassian REST API directly. Only returned when the requesting viewer is the
  owner of this integration; null otherwise or when no token is available. Do not cache
  this value — treat it as ephemeral.
  """
  accessToken: ID
  """
  The Atlassian account ID (e.g. "5b10a2844c20165700ede21g") of the user who authorized
  the integration. This is the Atlassian-side identifier and can be used in Jira API calls
  to reference the user.
  """
  accountId: ID!
  """
  The list of Atlassian cloud site IDs (e.g. "your-domain.atlassian.net" instance IDs) that
  the user has granted Parabol access to. A user may have multiple Atlassian organizations;
  this list scopes which ones are available. Required when constructing Atlassian API URLs,
  which are of the form https://api.atlassian.com/ex/jira/{cloudId}/...
  """
  cloudIds: [ID!]!
  """
  Timestamp when this integration record was first created, i.e. when the user first
  connected their Atlassian account to this Parabol team.
  """
  createdAt: DateTime!
  """
  The Parabol team ID that this integration belongs to. The integration is scoped to a
  single team — the same Atlassian account connected to two different teams creates two
  separate AtlassianIntegration records.
  """
  teamId: ID!
  """
  Timestamp when the OAuth tokens were last refreshed or the integration record was last
  modified. Useful for determining how recently the integration was active.
  """
  updatedAt: DateTime!
  """
  The Parabol user ID of the person who owns this integration. Together with teamId, this
  uniquely identifies the integration. Only that user can see sensitive fields like
  accessToken.
  """
  userId: ID!
  """
  All Jira projects accessible to this user across all connected Atlassian cloud sites.
  Fetched in real time from the Atlassian API. Returns an empty list if the viewer is not
  the owner of this integration, or if the user has no accessible projects. Use this to
  populate project pickers when the user is adding a Jira issue to a Parabol meeting.
  """
  projects: [JiraRemoteProject!]!
  """
  The user's recent Jira search queries, ordered from most recently used to oldest.
  Only includes queries used within the last 60 days. Use this to populate a
  "recent searches" dropdown so the user can quickly repeat previous searches.
  """
  jiraSearchQueries: [JiraSearchQuery!]!
  """
  A paginated list of Jira issues fetched live from the Jira API for this team member.
  Returns an empty connection if the viewer is not the owner of this integration.
  Use this to let users search for and select Jira issues to bring into a Parabol meeting.
  """
  issues(
    """Maximum number of issues to return per page. Defaults to 100."""
    first: Int = 100
    """
    Pagination cursor — the value of endCursor from a previous page's pageInfo. Omit to
    start from the beginning.
    """
    after: String
    """
    A plain-text search string (matched against issue summary and description) or a full
    JQL query string when isJQL is true. Omit or pass an empty string to return all issues
    the user can access.
    """
    queryString: String
    """
    Set to true when queryString contains a JQL expression (Jira Query Language), which
    allows advanced filtering by project, assignee, status, sprint, etc. Set to false for
    simple keyword search.
    """
    isJQL: Boolean!
    """
    Optional list of Jira project keys (e.g. ["ENG", "INFRA"]) to restrict results to
    specific projects. When omitted, issues from all accessible projects are returned.
    """
    projectKeyFilters: [ID!]
  ): JiraIssueConnection!
}

"""
An authentication strategy linked to a Parabol user account. A user may have multiple identities (e.g. both a local password and a Google SSO login). Concrete implementations are AuthIdentityLocal, AuthIdentityGoogle, and AuthIdentityMicrosoft. Use the type field to discriminate between them.
"""
interface AuthIdentity {
  """
  true if the email address associated with this identity has been verified by the provider, false if verification is still pending. For Google and Microsoft identities this is always true because the OAuth provider guarantees it; for local (email/password) identities it reflects whether the user has clicked the verification link.
  """
  isEmailVerified: Boolean!
  """
  Discriminator that identifies which concrete identity type this is (LOCAL, GOOGLE, or MICROSOFT). Use this to determine whether to cast to AuthIdentityLocal, AuthIdentityGoogle, or AuthIdentityMicrosoft when you need provider-specific fields such as the OAuth provider ID.
  """
  type: AuthIdentityTypeEnum!
}

"""
An authentication identity backed by Google OAuth. A user account may have this identity if they signed up or linked their account via "Sign in with Google". Use this type (via the AuthIdentity interface) to distinguish Google-authenticated users from those using local passwords or Microsoft OAuth.
"""
type AuthIdentityGoogle implements AuthIdentity {
  """
  true if the email address associated with this Google identity has been verified by Google, else false. Google accounts are almost always verified; check this before trusting the email for sensitive operations.
  """
  isEmailVerified: Boolean!
  """
  The authentication strategy discriminator. Always GOOGLE for this type. Use this field when you need to branch logic based on how the user authenticates (e.g. to show the correct "sign in with" button or to filter identities by provider).
  """
  type: AuthIdentityTypeEnum!
  """
  The unique Google account ID (the "sub" claim from Google's ID token) for this identity. Use this to correlate the Parabol user with a specific Google account, or to look up the identity when a user has multiple auth strategies on their account.
  """
  id: ID!
}

"""
An authentication identity backed by a locally-stored email address and hashed
password. This is the classic username/password login strategy. Use this type
(rather than AuthIdentityGoogle or AuthIdentityMicrosoft) when the user signed
up via Parabol's own registration form and authenticates without an external
OAuth provider.
"""
type AuthIdentityLocal implements AuthIdentity {
  """
  true if the user has confirmed ownership of the email address (e.g. by
  clicking a verification link), false if the address is still unconfirmed.
  Unverified users may have restricted access to certain features.
  """
  isEmailVerified: Boolean!
  """
  Discriminator that identifies this as the LOCAL authentication strategy.
  Always LOCAL for this type. Use this field to distinguish AuthIdentityLocal
  from other AuthIdentity implementations (GOOGLE, MICROSOFT) when working
  with a union or interface value.
  """
  type: AuthIdentityTypeEnum!
}

"""
An authentication strategy that uses a Microsoft account (Azure AD / Microsoft Entra ID) to verify a user's identity. Present on a user when they have linked or signed in with Microsoft OAuth. Use this type when distinguishing Microsoft-authenticated users from those using Google or local (email + password) auth.
"""
type AuthIdentityMicrosoft implements AuthIdentity {
  """
  True if Microsoft has verified the email address associated with this identity, false otherwise. Microsoft OAuth accounts are typically verified, but this should be checked before treating the email as trusted.
  """
  isEmailVerified: Boolean!
  """
  The authentication strategy discriminator. Always MICROSOFT for this type. Useful when iterating over a user's AuthIdentity list to filter or branch on the specific strategy.
  """
  type: AuthIdentityTypeEnum!
  """
  The unique identifier assigned by Microsoft (the Azure AD object ID or subject claim) for this user's Microsoft account. Use this to correlate the Parabol user with their Microsoft identity without relying on email address.
  """
  id: ID!
}

"""
The authentication strategy used to verify a user's identity. Each user account may have multiple linked identities of different types. Use this to determine how a user logs in and what credentials they manage.
"""
enum AuthIdentityTypeEnum {
  """
  Email and password authentication managed by Parabol. The user registered with an email address and a hashed password stored in Parabol's own database. Supports email verification, password reset flows, and is the only identity type where the user controls a password directly in Parabol.
  """
  LOCAL
  """
  OAuth 2.0 authentication via Google Sign-In. The user logs in through Google and Parabol receives a verified Google ID token. No password is stored; the user's email verification status is sourced from Google.
  """
  GOOGLE
  """
  OAuth 2.0 authentication via Microsoft (Azure AD / Entra ID). The user logs in through Microsoft and Parabol receives a verified Microsoft ID token. Includes a tenant ID (tid) that identifies the user's Microsoft organization, enabling tenant-scoped SSO enforcement.
  """
  MICROSOFT
}

"""
A replacement auth token pushed to the client over the notification subscription when the server issues a new JWT on behalf of the viewer. This happens whenever the server-side token state diverges from what the client holds — most commonly after the viewer joins or is removed from a team, which changes the list of team IDs (tms) embedded in the token. Upon receiving this payload the client must replace its stored JWT with the new one and use it for all subsequent requests.
"""
type AuthTokenPayload {
  """
  The newly-issued JWT, encoded and unsigned, that the client should store and attach to future requests. Decoding this token exposes standard JWT claims (sub, iat, exp, iss, aud, jti) plus Parabol-specific claims: tms (array of team IDs the viewer belongs to), rol (optional elevated role such as 'su' or 'impersonate'), bet (present when the viewer is a beta tester), and scope (optional OAuth-style permission scopes).
  """
  id: ID!
}

"""
The result of the autogroup mutation, which applies AI-suggested reflection groupings to a retrospective meeting. Returns AutogroupSuccess on success or ErrorPayload if something went wrong (e.g. meeting not found, not a retrospective, or no AI suggestions available yet).
"""
union AutogroupPayload = ErrorPayload | AutogroupSuccess

"""
A single AI-generated reflection group proposed by OpenAI during a retrospective meeting.
Produced by the autogroup mutation, which calls OpenAI to cluster a meeting's reflections
into thematically similar groups and gives each cluster a descriptive title.
This type is used in two places on RetrospectiveMeeting:
  - autogroupReflectionGroups: the current AI-suggested grouping
  - resetReflectionGroups: a snapshot of the grouping that existed before autogroup ran,
    used to restore the original arrangement if the facilitator rejects the AI suggestion.
"""
type AutogroupReflectionGroup {
  """
  The AI-generated display title summarising the theme shared by the reflections in this group.
  Produced by OpenAI based on the text content of the reflections and the prompt question they answered.
  """
  groupTitle: String!
  """
  The IDs of the RetroReflection records assigned to this group.
  Use these IDs to look up the full reflection objects and render the group's cards.
  """
  reflectionIds: [ID!]!
}

"""
Returned when the autogroup mutation succeeds. The mutation uses OpenAI to cluster
retrospective reflections into thematically similar groups and rearranges them
accordingly. The meeting's autogroupReflectionGroups field holds the AI-suggested
groupings, and resetReflectionGroups is snapshot of the groups before grouping so
the facilitator can undo via resetReflectionGroups mutation.
"""
type AutogroupSuccess {
  """
  The retrospective meeting whose reflections were just regrouped by AI. Fetch
  autogroupReflectionGroups on this meeting to see the AI-suggested clusters, or
  resetReflectionGroups to see the snapshot that was saved so the grouping can be undone.
  """
  meeting: RetrospectiveMeeting!
}

"""
Represents a single team member's Azure DevOps integration, including their OAuth2 credentials,
the ADO instances they have access to, and helpers for querying work items and projects. One record
exists per (team, user) pair. Use this type to fetch ADO work items for display in Parabol (e.g.
linking a task to an ADO work item during a meeting) or to surface the member's available ADO
projects and saved search queries.
"""
type AzureDevOpsIntegration {
  """
  The OAuth2 access and refresh tokens for this team member's Azure DevOps connection. Null when
  the user has not yet authorized Parabol to access their ADO account, or when the token has been
  revoked. Check this field before attempting to fetch work items or projects.
  """
  auth: TeamMemberIntegrationAuthOAuth2
  """
  Composite primary key in the format "ado:{teamId}:{userId}". Uniquely identifies this integration
  record across all teams and users.
  """
  id: ID!
  """
  The Azure DevOps account (organization-level) ID associated with this integration. Corresponds to
  the ADO organization that owns the instances the user granted access to.
  """
  accountId: ID!
  """
  The list of Azure DevOps instance (organization) IDs the user has explicitly granted Parabol
  access to. Each entry is an ADO organization URL slug or ID. Use this to scope API requests to
  only the instances the user has authorized.
  """
  instanceIds: [ID!]!
  """
  The timestamp when this integration record was first created, i.e. when the user first connected
  their ADO account to this Parabol team.
  """
  createdAt: DateTime!
  """
  The Parabol team ID this integration belongs to. An ADO integration is always scoped to a single
  team — the same ADO account can be connected to multiple teams, each producing a separate record.
  """
  teamId: ID!
  """
  The timestamp when this integration record was last updated, e.g. when the OAuth token was
  refreshed or when the user updated their authorized instances.
  """
  updatedAt: DateTime!
  """
  The Parabol user ID of the team member who owns this integration. Combined with teamId, this
  uniquely identifies the integration.
  """
  userId: ID!
  """
  A paginated list of Azure DevOps work items fetched live from the ADO API for this team member.
  Use this field to search for work items to link to a Parabol task or meeting agenda item. Supports
  free-text search or full WIQL (Work Item Query Language) for advanced filtering. Results are
  ordered by most recently updated first.
  """
  workItems(
    """
    Maximum number of work items to return. Defaults to 100. Use with `after` for pagination.
    """
    first: Int = 100
    """
    An ISO8601 datetime cursor for pagination. Pass the `endCursor` from a previous page's
    `pageInfo` to retrieve the next page of results.
    """
    after: DateTime
    """
    A plain-text search string, or a full WIQL query string if `isWIQL` is true. When plain text,
    the ADO API performs a full-text search against work item titles and descriptions. Leave null or
    empty to return the most recently updated items without filtering.
    """
    queryString: String
    """
    An optional list of ADO project IDs or names to restrict the search to. Pass an empty array or
    omit filtering to search across all projects the user has access to within their authorized
    instances.
    """
    projectKeyFilters: [String!]!
    """
    Set to true when `queryString` contains a WIQL (Work Item Query Language) expression, which
    allows advanced filtering by any work item field. Set to false (or omit) for a simple
    full-text keyword search.
    """
    isWIQL: Boolean!
  ): AzureDevOpsWorkItemConnection!
  """
  The complete list of Azure DevOps projects the team member has access to across all of their
  authorized instances. Use this to populate a project picker so the user can filter work item
  searches by project.
  """
  projects: [AzureDevOpsRemoteProject!]!
  """
  The global (cloud-level) OAuth2 integration provider for Azure DevOps configured via Parabol
  environment variables. This is the system-wide ADO provider available to all teams. Null when
  no cloud ADO provider has been configured in the environment (i.e. the ADO integration is
  disabled at the instance level).
  """
  cloudProvider: IntegrationProviderOAuth2
  """
  OAuth2 integration providers for Azure DevOps that have been shared at the team or organization
  level (as opposed to the global cloud provider). These are custom ADO provider configurations an
  admin has made available to specific teams. Use this list alongside `cloudProvider` to show the
  user all available ADO providers they can authorize against.
  """
  sharedProviders: [IntegrationProviderOAuth2!]!
  """
  The team member's saved Azure DevOps search queries, sorted by most recently used. Only queries
  used within the last 60 days are included. Use this to populate a "recent searches" UI so the
  user can quickly re-run a previous work item search without retyping their query or filters.
  """
  azureDevOpsSearchQueries: [AzureDevOpsSearchQuery!]!
}

"""
A Team Project fetched live from the Azure DevOps REST API. Implements RepoIntegration so it
can appear alongside Jira, GitHub, and other repo integrations in project-picker UIs. Use this
type when you need project-level metadata (name, state, visibility) to let a user select which
Azure DevOps project to link work items against, or when you need to navigate from a work item
back to its parent project.
"""
type AzureDevOpsRemoteProject implements RepoIntegration {
  """
  Globally unique identifier for this project within Parabol, composed as
  instanceId:projectId (e.g. "dev.azure.com/myorg:abc123"). Use this when
  referencing the project in mutations or as a cache key.
  """
  id: ID!
  """
  Always "azureDevOps". Identifies the integration provider so clients can
  route this RepoIntegration to the correct handler.
  """
  service: IntegrationProviderServiceEnum!
  """
  The Parabol team ID on whose behalf this project was fetched. Used to scope
  the result to the correct team context.
  """
  teamId: ID!
  """
  The Parabol user ID on whose behalf this project was fetched. The OAuth
  token belonging to this user was used to make the Azure DevOps API request.
  """
  userId: ID!
  """
  Timestamp of the most recent change to this project in Azure DevOps, as
  returned by the API. Useful for sorting or detecting stale data.
  """
  lastUpdateTime: DateTime!
  """
  The Azure DevOps REST API URL for this project's own resource endpoint
  (the href from _links.self). Use this to make direct API calls or to
  construct deep links into the Azure DevOps UI.
  """
  self: ID!
  """
  The Azure DevOps organization instance hostname, e.g. "dev.azure.com/myorg".
  Combined with the project name or ID this uniquely identifies the project
  across all Azure DevOps organizations the user has access to.
  """
  instanceId: ID!
  """
  The human-readable display name of the Team Project in Azure DevOps, e.g.
  "MyApp Backend". Show this in project-picker dropdowns and task detail views.
  """
  name: String!
  """
  A monotonically increasing integer that Azure DevOps increments each time
  the project's metadata is updated. Useful for detecting whether locally
  cached project data is out of date compared to the remote.
  """
  revision: Int!
  """
  The lifecycle state of the project as reported by Azure DevOps. Common
  values are "wellFormed" (active and fully provisioned), "createPending",
  "deleting", "deleted", and "new". Only "wellFormed" projects are fully
  usable for creating and querying work items.
  """
  state: String!
  """
  The Azure DevOps REST API URL for this project, e.g.
  "https://dev.azure.com/myorg/_apis/projects/abc123". Can be used to fetch
  further project details directly from the Azure DevOps API.
  """
  url: String!
  """
  Access visibility of the project within Azure DevOps. Either "private"
  (accessible only to members) or "public" (accessible to anyone). Surfaces
  in the UI when helping users understand who can see linked work items.
  """
  visibility: String!
}

"""
A saved Azure DevOps work-item search query, capturing the query string and any
filters that were active when the query was last run. These are persisted per-user
so that recently used searches can be surfaced and re-executed quickly during
sprint planning or issue scoping.
"""
type AzureDevOpsSearchQuery {
  """A short unique identifier for this saved search query."""
  id: ID!
  """
  The search string used to find work items. When isWIQL is false this is a
  plain-text keyword search; when isWIQL is true this is a full WIQL (Work Item
  Query Language) statement, which supports WHERE clauses, field comparisons, and
  ordering (e.g. "SELECT [Id] FROM WorkItems WHERE [System.State] = 'Active'").
  """
  queryString: String!
  """
  An optional list of Azure DevOps project keys (slugs) used to narrow results to
  specific projects. An empty array means the query runs across all projects the
  user has access to. Each entry corresponds to an Azure DevOps project name or ID.
  """
  projectKeyFilters: [String!]!
  """
  When true, queryString must be a valid WIQL statement and will be sent to the
  Azure DevOps WIQL endpoint directly. When false, queryString is treated as a
  simple keyword search and project-level filters are applied separately.
  """
  isWIQL: Boolean!
  """
  The timestamp of the most recent time this query was executed. Used to sort saved
  queries so the most recently used ones appear first in the UI.
  """
  lastUsedAt: DateTime!
}

"""
An Azure DevOps work item fetched in real time from the Azure DevOps REST API.
Implements TaskIntegration, meaning a Parabol Task can be linked to this work item
so that changes (e.g. title, state) are reflected back to Azure DevOps.
Use this type when displaying, linking, or syncing a specific work item inside a Parabol task or retro card.
"""
type AzureDevOpsWorkItem implements TaskIntegration {
  """
  Globally unique identifier for this work item within Parabol, formed by joining the Azure DevOps
  instance ID, the team project name/ID, and the numeric work item ID with colons:
  "<instanceId>:<teamProject>:<issueKey>" (e.g. "a1b2c3.visualstudio.com:MyProject:42").
  Use this as the stable reference when storing or querying the work item inside Parabol.
  """
  id: ID!
  """
  The direct browser URL to open this work item in Azure DevOps
  (e.g. "https://dev.azure.com/org/MyProject/_workitems/edit/42").
  Use this to link users directly to the work item in the Azure DevOps UI.
  """
  url: String!
  """
  The numeric work item ID assigned by Azure DevOps (e.g. "42").
  This is the raw ID as it appears in Azure DevOps, without any project or instance prefix.
  Use this when displaying the work item reference or constructing Azure DevOps API calls.
  """
  issueKey: String!
  """
  The human-readable title (name) of the work item, equivalent to the "Title" field in Azure DevOps.
  Use this for display purposes wherever a short label for the work item is needed.
  """
  title: String!
  """
  The name or ID of the Azure DevOps Team Project that owns this work item
  (e.g. "MyProject"). Team Projects are the top-level organizational unit inside an Azure DevOps instance.
  Use this to scope API calls or to display which project the work item belongs to.
  """
  teamProject: String!
  """
  The full AzureDevOpsRemoteProject record for the team project that owns this work item.
  Provides richer project metadata (instance ID, visibility, revision, etc.) beyond the plain teamProject name.
  Use this when you need project-level details alongside the work item, such as constructing links or
  validating access.
  """
  project: AzureDevOpsRemoteProject!
  """
  The current workflow state of the work item as defined in Azure DevOps (e.g. "Active", "Resolved", "Closed").
  The available states depend on the work item type and the process template configured for the project.
  Use this to show progress, filter by status, or decide whether a task should be marked complete in Parabol.
  """
  state: String!
  """
  The work item type as defined in Azure DevOps (e.g. "Bug", "User Story", "Task", "Epic").
  The available types depend on the process template (Agile, Scrum, CMMI) configured for the project.
  Use this to display the correct icon/label or to differentiate handling between bugs and stories.
  """
  type: String!
  """
  The work item's description field rendered as an HTML string.
  Azure DevOps stores descriptions as HTML; this field exposes that HTML directly so it can be
  rendered in a rich-text context. May be an empty string if the work item has no description.
  Use this when showing a preview of the work item's details inside Parabol (e.g. in a task drawer).
  """
  descriptionHTML: String!
}

"""
A Relay-style paginated connection for Azure DevOps work items fetched from a user's Azure DevOps integration. Use this type when listing work items to import as Parabol tasks or when searching for work items to link to a task. Pagination is cursor-based using ISO8601 date cursors. Check the error field before iterating edges — if the integration is misconfigured or the request fails, edges will be empty and error will explain why.
"""
type AzureDevOpsWorkItemConnection {
  """
  Pagination metadata for this page of results. Use the cursors here to fetch the next or previous page of work items.
  """
  pageInfo: PageInfoDateCursor
  """
  The list of work item edges on this page. Each edge wraps a single AzureDevOpsWorkItem node and a cursor that can be used to resume pagination from that position.
  """
  edges: [AzureDevOpsWorkItemEdge!]!
  """
  Present when the connection could not be loaded, for example when the Azure DevOps integration is missing, the access token has expired, or the requested project does not exist. When this field is non-null, edges will be empty and pageInfo will be absent.
  """
  error: StandardMutationError
}

"""
A pagination edge wrapping a single Azure DevOps work item in a cursor-based connection.
Use this type when iterating over a paginated list of work items returned from AzureDevOpsWorkItemConnection.
Each edge pairs the work item node with a cursor that marks its position in the result set,
allowing subsequent queries to resume from that point using the cursor as a pagination argument.
"""
type AzureDevOpsWorkItemEdge {
  """
  The Azure DevOps work item at this position in the paginated result set.
  """
  node: AzureDevOpsWorkItem!
  """
  An opaque ISO8601 DateTime cursor representing this edge's position in the connection.
  Pass this value as the `after` argument on the parent connection query to fetch the next page of results starting after this work item.
  Null if the work item has no associated timestamp for ordering.
  """
  cursor: DateTime
}

"""
The result of the batchArchiveTasks mutation. Returns BatchArchiveTasksSuccess when at least the
archive operation completes (even if some tasks were skipped due to permission checks), or
ErrorPayload if the operation could not proceed at all (e.g. authentication failure).
"""
union BatchArchiveTasksPayload = ErrorPayload | BatchArchiveTasksSuccess

"""
Returned when batchArchiveTasks succeeds. Contains only the tasks that were
actually archived — tasks the viewer lacked permission to archive (neither the
task creator nor a member of the task's team) are silently excluded from both
lists.
"""
type BatchArchiveTasksSuccess {
  """
  IDs of the tasks that were successfully archived. May be a subset of the
  input taskIds if the viewer did not have permission to archive every requested
  task.
  """
  archivedTaskIds: [ID!]
  """
  Full Task objects for every successfully archived task. Populated when the
  caller needs task details beyond IDs (e.g. to update local UI state). Null
  when the resolver returns only IDs via the team subscription broadcast.
  """
  archivedTasks: [Task!]
}

"""
The type of entity to check access for, used as an argument to User.canAccess.
Lets callers determine whether the viewer has permission to see a specific resource
(e.g. to distinguish a "not found" error from an "invite required" situation).
"""
enum CanAccessEntity {
  """
  A team the viewer may or may not be a member of. Use to check whether the viewer
  can see team details before prompting them to request membership.
  """
  Team
  """
  A meeting (retrospective, standup, poker, etc.) that may be restricted to team members.
  Use to determine whether the viewer needs an invite link to join.
  """
  Meeting
  """
  An organization the viewer may or may not belong to. Use to check visibility before
  directing the viewer to request access or an invitation.
  """
  Organization
}

"""
Identifies how a change to a record was initiated. Used on TaskEstimate to distinguish
whether a story-point estimate was set during a poker planning meeting, updated directly
on the task outside of a meeting, or synchronized in from an external integration such
as Jira or Azure DevOps.
"""
enum ChangeSourceEnum {
  """
  The change was made during a Parabol poker planning meeting (Sprint Poker). Use this
  value when an estimate is recorded as the outcome of a team vote in a meeting stage.
  """
  meeting
  """
  The change was made directly on the task itself, outside of any meeting context. Use
  this value when a user edits an estimate from the task detail view or task list.
  """
  task
  """
  The change originated from an external integration, such as a Jira or Azure DevOps
  webhook or sync. Use this value when the estimate was pushed into Parabol by a
  third-party service rather than by a user action within the app.
  """
  external
}

"""
Returned by the changeTaskTeam mutation, which reassigns a task from one team to another.
Contains the updated task for members of the new team, an error if the operation failed,
and the removed task ID for users who are no longer permitted to see the task after the move.
"""
type ChangeTaskTeamPayload {
  """
  Present when the mutation fails; describes what went wrong so the client can surface an error message.
  """
  error: StandardMutationError
  """
  The task after being reassigned to the new team, including any updated team-scoped fields.
  Null if the viewer is not a member of the new team (use removedTaskId instead).
  """
  task: Task
  """
  The ID of the task that was moved, sent only to viewers who are not members of the new team.
  Clients should use this to evict the task from their local store when they receive this payload.
  """
  removedTaskId: ID
}

"""
The icebreaker phase that opens Action and Retrospective meetings. Each team member gets their own CheckInStage and responds to a shared question of the week before the substantive meeting work begins. The phase includes a rotating multilingual greeting and a randomly-selected icebreaker question, both seeded by the team ID and meeting count so they vary across meetings.
"""
type CheckInPhase implements NewMeetingPhase {
  """Unique identifier for this phase instance (shortid)"""
  id: ID!
  """The ID of the meeting this phase belongs to"""
  meetingId: ID!
  """The ID of the team running this meeting"""
  teamId: ID!
  """The type of phase — always 'checkin' for this type"""
  phaseType: NewMeetingPhaseTypeEnum!
  """
  One stage per team member, ordered by team member position. Each stage represents a single team member's turn to answer the check-in question. Iterate these to show progress through the phase or to render each member's check-in turn.
  """
  stages: [CheckInStage!]!
  """
  A randomly-selected greeting in a non-English language, shown at the top of the check-in phase to add a fun, multicultural touch. Rotates each meeting based on the team ID and meeting count. Use this to display the opening greeting word alongside its source language.
  """
  checkInGreeting: MeetingGreeting!
  """
  The icebreaker question posed to every team member during check-in, stored as a stringified TipTap JSON document. Rotates each meeting based on the team ID and meeting count. Parse and render this with a TipTap-compatible renderer. The trailing "?" is typically appended by the UI component.
  """
  checkInQuestion: String!
}

"""
A single stage within the check-in phase of an Action meeting, scoped to one team member. The check-in phase contains one CheckInStage per team member, and the facilitator advances through them sequentially. Each stage presents the check-in question to the focused team member, who answers before the meeting moves on. Use this type when you need to inspect or display the per-member check-in status, readiness, or timing within a meeting.
"""
type CheckInStage implements NewMeetingStage & NewMeetingTeamMemberStage {
  """stageId, shortid"""
  id: ID!
  """The datetime the stage was completed"""
  endAt: DateTime
  """foreign key. try using meeting"""
  meetingId: ID!
  """The meeting this stage belongs to"""
  meeting: NewMeeting!
  """
  true if the facilitator has completed this stage, else false. Should be boolean(endAt)
  """
  isComplete: Boolean!
  """true if any meeting participant can navigate to this stage"""
  isNavigable: Boolean!
  """true if the facilitator can navigate to this stage"""
  isNavigableByFacilitator: Boolean!
  """The phase this stage belongs to"""
  phase: NewMeetingPhase
  """The type of the phase"""
  phaseType: NewMeetingPhaseTypeEnum
  """The datetime the stage was started"""
  startAt: DateTime
  """Number of times the facilitator has visited this stage"""
  viewCount: Int
  """
  true if a time limit is set, false if end time is set, null if neither is set
  """
  isAsync: Boolean
  """true if the viewer is ready to advance, else false"""
  isViewerReady: Boolean!
  """User ids of those who are ready to advance to the next stage"""
  readyUserIds: [ID!]!
  """
  The datetime the phase is scheduled to be finished, null if no time limit or end time is set
  """
  scheduledEndTime: DateTime
  """
  The suggested ending datetime for a phase to be completed async, null if not enough data to make a suggestion
  """
  suggestedEndTime: DateTime
  """
  The suggested time limit for a phase to be completed together, null if not enough data to make a suggestion
  """
  suggestedTimeLimit: Float
  """
  The id of the team this stage belongs to. Useful for scoping queries without fetching the full meeting.
  """
  teamId: ID!
  """
  The number of milliseconds left before the scheduled end time. Useful for unsynced client clocks. null if scheduledEndTime is null
  """
  timeRemaining: Float
  """
  The 0-based position of this stage within its phase, ordered by sortOrder.
  """
  stageIdx: Int!
  """The meeting member that is the focus for this phase item"""
  meetingMember: MeetingMember!
  """foreign key. use teamMember"""
  teamMemberId: ID!
  """The team member that is the focus for this phase item"""
  teamMember: TeamMember!
}

"""
A comment posted in a discussion thread. Comments can be top-level posts or replies to other
Threadable items (including other Comments). They support emoji reactions via the Reactable
interface and can be posted anonymously. When a comment is deleted its content is replaced
with tombstone text but the record is retained (isActive becomes false) so that reply
threading is preserved.
"""
type Comment implements Reactable & Threadable {
  """Unique short ID for this comment."""
  id: ID!
  """
  The rich-text (Prosemirror JSON serialised as a string) body of the comment. When the
  comment has been deleted (isActive is false) this contains tombstone placeholder text
  rather than the original content.
  """
  content: String!
  """The timestamp when this comment was first created."""
  createdAt: DateTime!
  """
  The ID of the user who created this comment. Null when the comment was posted anonymously
  (isAnonymous is true).
  """
  createdBy: ID
  """
  The full User object for the comment author. Null when the comment was posted anonymously
  (isAnonymous is true). Prefer this over createdBy when you need to display author details.
  """
  createdByUser: User
  """
  All direct replies to this comment, returned as an ordered list of Threadable items.
  An empty array means no one has replied yet.
  """
  replies: [Threadable!]!
  """
  The ID of the Discussion thread this comment belongs to. Null if the comment was not
  created inside a discussion (e.g. it was created on a Task directly).
  """
  discussionId: ID
  """
  The ID of the parent Threadable item when this comment is a reply. Null when this comment
  is a top-level post in the thread rather than a reply.
  """
  threadParentId: ID
  """
  Numeric sort key that determines the display order of this comment relative to its siblings
  that share the same threadParentId. Lower values appear first.
  """
  threadSortOrder: Int
  """
  The timestamp when this comment was last modified (e.g. content edited or reactions changed).
  """
  updatedAt: DateTime!
  """
  The emoji reactions that have been added to this comment, grouped by emoji so each entry
  represents one distinct reactji and includes how many users reacted with it.
  """
  reactjis: [Reactji!]!
  """
  False when the comment has been soft-deleted. Soft-deleted comments retain their record
  so that reply threading is not broken, but their content is replaced with tombstone text.
  """
  isActive: Boolean!
  """
  True when the comment was posted anonymously. When true, createdBy and createdByUser are
  null and the author's identity must not be surfaced in the UI.
  """
  isAnonymous: Boolean!
  """
  True when the currently authenticated viewer is the author of this comment. Use this to
  conditionally show edit and delete controls.
  """
  isViewerComment: Boolean!
}

"""
A lightweight snapshot of a user who is actively commenting on a retro reflection group thread.
Contains only the identity fields needed to display a commenter indicator, rather than the full User type.
Note: this type is deprecated on RetroReflectionGroup — commentor presence has moved to ThreadConnection.
"""
type CommentorDetails {
  """
  The userId of the person commenting. Matches the id field on the User type and can be used to fetch the full user record if more details are needed.
  """
  id: ID!
  """
  The display name the user has chosen (e.g. "Jane Smith"). Use this to label the commenter in the UI without needing a separate User lookup.
  """
  preferredName: String!
}

"""
A Company groups one or more Organizations that share the same top-level domain (e.g. "acme.com").
It is created and maintained automatically — whenever a user joins or creates an Organization,
Parabol extracts the TLD from their email address and associates that Organization with the
matching Company. Use Company when you need aggregate metrics (usage, billing tier, engagement)
across every Organization that belongs to the same corporate entity.
"""
type Company {
  """
  The top-level domain that uniquely identifies this company (e.g. "acme.com").
  Derived from user email addresses and used as the primary key.
  """
  id: ID!
  """
  The total number of non-archived teams that are currently active across all
  Organizations belonging to this company.
  """
  activeTeamCount: Int!
  """
  The number of distinct users who are members of at least one Organization in
  this company and are not marked inactive. Pass `after` to restrict the count
  to users who joined after a specific point in time — useful for measuring
  recent growth.
  """
  activeUserCount(
    """
    When provided, only users whose Organization membership began after this
    timestamp are counted. Omit to count all non-inactive members.
    """
    after: DateTime
  ): Int!
  """
  The number of Organizations within this company that are considered "active":
  they must have at least one non-archived team and at least two team members
  who have logged in within the last 30 days.
  """
  activeOrganizationCount: Int!
  """
  The timestamp of the most recently started meeting across every team in every
  Organization belonging to this company. Returns null if no meetings have ever
  been run.
  """
  lastMetAt: DateTime
  """
  The total number of meetings that have been started across all teams in all
  Organizations belonging to this company. Pass `after` to count only meetings
  created on or after that timestamp.
  """
  meetingCount(
    """
    When provided, only meetings created on or after this timestamp are counted.
    """
    after: DateTime
  ): Int!
  """
  The longest streak (in consecutive calendar months) during which at least one
  team in the company ran a meeting every month. A streak resets if any calendar
  month passes without a completed meeting. Useful as an engagement health signal.
  """
  monthlyTeamStreakMax: Int!
  """
  All Organizations that belong to this company. The list is visibility-scoped:
  enterprise-tier members and super-users see every Organization; other members
  see only the Organizations they personally belong to.
  """
  organizations: [Organization!]!
  """
  The highest billing tier that any organization user across this company has been
  nudged to upgrade to, based on their `suggestedTier` field. Returns null if no
  upgrade nudge is in effect. "starter" means no upgrade is suggested; "team" or
  "enterprise" indicates the recommended next tier. This drives upsell prompts in
  the UI — use `tier` instead if you want the current paid tier rather than the
  suggested one.
  """
  suggestedTier: TierEnum
  """
  The highest billing tier currently active across all Organizations in this
  company. Determined by inspecting each Organization's `tier` field and
  returning the highest value ("enterprise" > "team" > "starter"). Use this
  to determine what features the company already has access to.
  """
  tier: TierEnum!
  """
  The total number of distinct users who are members of at least one
  Organization in this company, regardless of activity or join date.
  """
  userCount: Int!
}

"""
The format in which an AI-generated string response should be returned.
Use this to control how the client will render the content — choose html if the
response will be injected directly into the DOM, or markdown if the client will
parse/render Markdown syntax (e.g. inside a Markdown renderer or plain-text
display). Defaults to markdown in most AI query fields.
"""
enum ContentFormatEnum {
  """
  The response is returned as an HTML string. Use when the caller will render
  the content directly in the DOM without an intermediate Markdown parser,
  e.g. setting innerHTML or using dangerouslySetInnerHTML in React.
  """
  html
  """
  The response is returned as a Markdown-formatted string. This is the default.
  Use when the caller will pass the content to a Markdown renderer or display
  it as plain text where Markdown syntax is acceptable.
  """
  markdown
}

"""
Input for the addAgendaItem mutation. Describes a new agenda item to be added to a team's Check-In meeting (meetingType: "action"). Agenda items represent topics a team member wants to discuss during the AgendaItemsPhase. Items can be created before a meeting starts or while one is in progress. Pinned items are automatically re-created at the start of each subsequent meeting so recurring topics always appear on the agenda.
"""
input CreateAgendaItemInput {
  """The text description of the topic to discuss. Maximum 64 characters."""
  content: String!
  """
  When true, this agenda item will be automatically cloned and re-added to the next Check-In meeting when the current meeting ends. Use for recurring topics the team discusses every meeting. Non-pinned items are cleared when the meeting closes.
  """
  pinned: Boolean!
  """The ID of the team this agenda item belongs to."""
  teamId: ID!
  """
  The ID of the team member who is creating this agenda item (format: teamId::userId). Determines who "owns" the item in the agenda list and whose avatar appears next to it.
  """
  teamMemberId: ID!
  """
  The fractional-index sort order used to position this item in the agenda list. If omitted, the server places the item at the end of the list. Provide a value to insert the item at a specific position between existing items.
  """
  sortOrder: String
  """
  The ID of the active Check-In meeting to associate this agenda item with. If provided, the item is linked to that meeting and will appear in its agenda phase. If omitted, the item is added to the team's agenda queue and will be associated with the next meeting that starts.
  """
  meetingId: String
}

"""
Input for creating a Google Calendar event that accompanies the start of a Parabol meeting
(Sprint Poker, Check-In, Retrospective, or Team Prompt). Provide this when the caller wants
to place a calendar event on team members' calendars at the same time the meeting is created.
All time values must be consistent: startTimestamp and endTimestamp should fall within the
wall-clock day described by timeZone.
"""
input CreateGcalEventInput {
  """
  Unix timestamp (seconds since epoch) for when the calendar event starts.
  Must be earlier than endTimestamp.
  """
  startTimestamp: Int!
  """
  Unix timestamp (seconds since epoch) for when the calendar event ends.
  Must be later than startTimestamp.
  """
  endTimestamp: Int!
  """
  IANA timezone name (e.g. "America/Los_Angeles") used to display the event's
  start and end times correctly in Google Calendar for each attendee.
  """
  timeZone: String!
  """
  List of email addresses to invite as attendees on the Google Calendar event.
  Each address receives a calendar invitation. If omitted or empty, no attendees
  are added beyond the organizer.
  """
  invitees: [Email!]
  """
  The video conferencing provider to attach to the calendar event.
  Use "meet" to add a Google Meet link, or "zoom" to add a Zoom link.
  If omitted, no video conferencing link is added to the event.
  """
  videoType: GcalVideoTypeEnum
}

"""
Payload returned by the createImposterToken mutation. On success, the server sets an
auth cookie scoped to the impersonated user (role: "impersonate", valid for 5 minutes),
allowing an admin to act as that user for troubleshooting without knowing their
credentials. The token is delivered via cookie, not as a field on this type.
"""
type CreateImposterTokenPayload {
  """
  Present when the mutation fails — for example when no user matches the supplied
  userId or email. Null on success.
  """
  error: StandardMutationError
  """
  The user whose identity was assumed. Use this to confirm which account the
  impersonation session was created for before redirecting or continuing.
  """
  user: User
}

"""
Payload returned by the createOAuth1AuthorizeUrl mutation. On success, contains
the authorization URL the client should redirect the user to in order to begin
the OAuth 1.0a three-legged authorization flow. The URL already contains the
oauth_token (request token) obtained from the provider, so the client only
needs to redirect to it. On failure, error is populated and url is null.
"""
type CreateOAuth1AuthorizationURLPayload {
  """
  Present when the mutation fails (e.g. invalid providerId, provider
  unreachable, or team not found). Null on success.
  """
  error: StandardMutationError
  """
  The provider's authorization endpoint URL with the oauth_token query
  parameter already appended. Redirect the user to this URL to have them grant
  access on the provider's site. After the user approves, the provider will
  redirect back with oauth_token and oauth_verifier, which are then used in the
  subsequent step to exchange for a permanent access token. Null on error.
  """
  url: String
}

"""
The result of a successful OAuth 2.0 authorization code request. Returned
when a user approves an OAuth 2.0 authorization flow initiated via
GET /oauth/authorize. The client application exchanges the code for an
access token by POSTing to /oauth/token with grant_type=authorization_code.
"""
type CreateOAuthAPICodePayload {
  """
  A short-lived, single-use authorization code (valid for 10 minutes) that
  the OAuth client exchanges for an access token at the /oauth/token endpoint.
  This code is tied to the requesting client_id, redirect_uri, user, and
  approved scopes.
  """
  code: String!
  """
  The opaque state value originally supplied by the OAuth client in the
  authorization request. Echoed back unchanged so the client can verify
  the response matches its request and guard against CSRF attacks. Null
  when the client did not include a state parameter.
  """
  state: String
}

"""
The result of successfully creating a new OAuth 2.0 API provider. The clientSecret is only
returned here and is never stored in a retrievable form — the caller must save it immediately.
"""
type CreateOAuthAPIProviderPayload {
  """
  The newly created OAuth 2.0 provider record, containing metadata such as name, redirect URIs, and scopes. Does not include the clientSecret.
  """
  provider: OAuthAPIProvider!
  """
  The public OAuth 2.0 client identifier for this provider. Safe to share; used by third-party clients when initiating authorization flows.
  """
  clientId: String!
  """
  The secret credential for this provider. Returned only once at creation time — it is not persisted in a readable form and cannot be retrieved later. Store it securely now.
  """
  clientSecret: String!
}

"""
The payload returned by the createPage mutation. Contains the newly created top-level page.
"""
type CreatePagePayload {
  """
  The newly created page, seeded with an empty heading and ready for content.
  """
  page: Page!
}

"""
Returned when a personal access token is successfully created. The plaintext token
is only available in this response — it is never retrievable again after creation,
so callers must store it immediately. Subsequent API calls use this token for
Bearer authentication.
"""
type CreatePersonalAccessTokenSuccess {
  """
  The plaintext token value — only returned once at creation, store it securely
  """
  token: String!
  """
  The persisted metadata record for the newly created token. Use this to display
  token details (name, scopes, expiry) to the user or to reference the token by
  ID for future revocation.
  """
  personalAccessToken: PersonalAccessToken!
}

"""
Input for the createPoll mutation. Creates a new poll inside a discussion thread during a meeting.
Polls let meeting participants vote on a question with 2–4 predefined options.
The caller must be an active member of the meeting that owns the discussion.
"""
input CreatePollInput {
  """
  The ID of the discussion thread in which the poll will appear.
  Determines which meeting and team the poll belongs to.
  """
  discussionId: ID!
  """
  Numeric sort key that controls where this poll appears within its thread, relative to other threadable items (comments, tasks, polls).
  Lower values appear first. Assign a value consistent with the ordering of existing items in the thread.
  """
  threadSortOrder: Int!
  """
  The question being posed to voters. Must be between 2 and 100 characters.
  """
  title: String!
  """
  The voting options presented to participants. Must contain between 2 and 4 items (inclusive).
  Every option must have a non-empty title. The order of items in this list determines display order.
  """
  options: [PollOptionInput!]!
}

"""
The result of the createPoll mutation. Returns CreatePollSuccess when the poll is
successfully created in a meeting discussion thread, or ErrorPayload when creation
fails (e.g. the discussion does not exist, the user lacks permission, or the input
is invalid). Callers should check the __typename field to distinguish the two cases.
"""
union CreatePollPayload = ErrorPayload | CreatePollSuccess

"""
The success payload returned by the createPoll mutation. Use this type (as opposed to ErrorPayload)
when the union CreatePollPayload resolves successfully. It gives you both the stable identifier of
the newly created poll and the full Poll object so you can immediately display or interact with the
poll without a follow-up query.
"""
type CreatePollSuccess {
  """
  The stable, globally unique identifier of the newly created poll, in the format
  `poll:<database-generated-id>`. Use this ID to reference the poll in subsequent mutations
  (e.g. vote on an option) or queries without needing to traverse the full Poll object.
  """
  pollId: ID!
  """
  The fully hydrated Poll object that was just created, including its title, voting options, the
  discussion it belongs to, the team it is scoped to, and authorship metadata. Use this field to
  render the poll UI immediately after creation rather than refetching it separately.
  """
  poll: Poll!
}

"""
Input for creating a new retro reflection during the reflect phase of a retrospective meeting.
Each reflection belongs to exactly one reflect prompt (category) and is placed in its own
newly-created reflection group. Reflections can only be added before the group phase is complete.
"""
input CreateReflectionInput {
  """
  A stringified TipTap JSONContent document containing the reflection's thoughts.
  Must be 2000 characters or fewer. If omitted or null, an empty document is created.
  The server normalises legacy formats to TipTap automatically.
  """
  content: String
  """
  The ID of the retrospective meeting in which to create the reflection.
  The meeting must be active (not ended) and must not have completed the group phase yet.
  """
  meetingId: ID!
  """
  The ID of the ReflectPrompt (category) this reflection answers, e.g. "What went well?".
  Determines which column the reflection appears in on the board. Immutable after creation.
  """
  promptId: ID!
  """
  The vertical sort position of the reflection's containing group within its prompt column.
  A new ReflectionGroup is created for this reflection and placed at this position.
  Use a float so items can be inserted between existing positions without renumbering.
  """
  sortOrder: Float!
}

"""
Payload returned by the createReflection mutation.

A successful call creates one RetroReflection and a new RetroReflectionGroup that
wraps it, both persisted to the database. The meeting's group phase is also unlocked
(made navigable for the facilitator) if this is the first reflection added to the
meeting. The payload is broadcast over the MEETING subscription channel so all
participants see the new card in real time.

Failure cases surfaced via error:
- promptId does not match a known ReflectPrompt ("Category not found")
- meetingId does not match a known meeting ("Meeting not found")
- The meeting has already ended ("Meeting already ended")
- The group phase of the meeting is already complete ("Meeting phase already completed")
- content exceeds 2 000 characters ("Reflection content is too long")
"""
type CreateReflectionPayload {
  """Present when the mutation failed. Null on success."""
  error: StandardMutationError
  """
  The retrospective meeting in which the reflection was created.
  Null when error is non-null.
  """
  meeting: NewMeeting
  """
  The ID of the newly created RetroReflection. Useful for optimistic updates
  before the full reflection object is needed.
  Null when error is non-null.
  """
  reflectionId: ID
  """
  The newly created RetroReflection containing the content, promptId, and
  creator information.
  Null when error is non-null.
  """
  reflection: RetroReflection
  """
  The new RetroReflectionGroup automatically created to hold this reflection.
  Every reflection starts in its own group; groups are later merged during the
  group phase. The group's title is initially derived from the reflection text
  and may be asynchronously upgraded to an AI-generated title.
  Null when error is non-null.
  """
  reflectionGroup: RetroReflectionGroup
  """
  Any meeting stages that were unlocked as a side-effect of adding this reflection.
  Specifically, the group phase stages are unlocked the first time any reflection is
  added to the meeting (i.e. when the group phase was not yet navigable by the
  facilitator). Empty or null when no stages changed state.
  """
  unlockedStages: [NewMeetingStage!]
}

"""
Return value for the createStripeSubscription mutation, which creates a new Stripe subscription
for an organization that does not yet have one. The caller provides an orgId and a Stripe
paymentMethodId. On success the mutation creates (or reuses) a Stripe customer, attaches the
payment method, and creates a team subscription billed by the number of active org members,
applying any pending coupon before clearing it from the org record.

Success: returns CreateStripeSubscriptionSuccess with a client secret the client must use to
confirm payment via the Stripe.js SDK (e.g. stripe.confirmCardPayment).

Failure: returns ErrorPayload. Common error cases include the organization already having an
active subscription, or Stripe rejecting the customer or payment method creation.
"""
union CreateStripeSubscriptionPayload = ErrorPayload | CreateStripeSubscriptionSuccess

"""
Returned by the createStripeSubscription mutation when a new Stripe subscription has been
successfully created for the given organization. The caller must use the
stripeSubscriptionClientSecret to confirm payment on the client side (e.g. via
stripe.confirmCardPayment) before the subscription becomes active.

Failure cases surfaced as ErrorPayload instead:
- The organization already has an active Stripe subscription (stripeSubscriptionId is set).
- Creating or retrieving the Stripe customer fails.
- Attaching the payment method to an existing customer fails.
"""
type CreateStripeSubscriptionSuccess {
  """
  The client secret from the Stripe PaymentIntent on the subscription's latest invoice.
  Pass this to stripe.confirmCardPayment (or equivalent) on the client using the
  Stripe publishable key to complete 3DS / SCA payment confirmation and activate the
  subscription. This value is single-use and short-lived; confirm payment immediately
  after receiving it.
  """
  stripeSubscriptionClientSecret: String!
}

"""
Input for the createTask mutation. Used to create a new task on a team, optionally scoped to a
meeting and/or a discussion thread. Tasks are the core unit of work in Parabol — they appear on
team and personal dashboards, can be assigned to a team member, and can be mirrored to an external
service (GitHub, GitLab, Jira, etc.) at creation time.

Required fields: status and teamId.

Failure cases:
- The viewer is not a member of the meeting specified by meetingId.
- The discussionId does not belong to the meeting specified by meetingId, or does not belong to the team.
- The userId is not a member of the team.
- The integration field refers to a project the viewer is not authorized to push to, or the external
  service returns an error.

Success: returns CreateTaskPayload with the newly created Task and any NotifyTaskInvolves
notifications generated for the assignee or @mentioned users.
"""
input CreateTaskInput {
  """
  The rich-text body of the task encoded as a TipTap/ProseMirror JSON document serialized to a
  string. If omitted or null, the task is created with an empty body. Inline @mentions of user IDs
  cause MENTIONEE notifications to be sent to those users. Tags such as #private and #archived can
  be embedded in the content and affect task visibility.
  """
  content: String
  """
  Plain-text version of the task body. When provided this value is stored directly; when omitted
  the server derives it from the content field. Useful for full-text search and notification
  previews.
  """
  plaintextContent: String
  """foreign key for the meeting this was created in"""
  meetingId: ID
  """foreign key for the thread this was created in"""
  discussionId: ID
  """
  The sort position of this task within its parent thread, used to order threaded replies relative
  to threadParentId. Only meaningful when threadParentId is set.
  """
  threadSortOrder: Int
  """
  The ID of the parent Threadable item (e.g. a reflection or comment) when this task is created as
  a reply inside a discussion thread. Null for top-level tasks.
  """
  threadParentId: ID
  """
  The position of this task in the shared team/user dashboard kanban column. Used by drag-and-drop
  ordering. If omitted, the server assigns a noise value that places the task at the end of the
  list.
  """
  sortOrder: Float
  """
  The initial workflow status of the task. Must be one of: active, stuck, done, or future. This
  field is required — there is no server-side default.
  """
  status: TaskStatusEnum!
  """teamId, the team the task is on"""
  teamId: ID!
  """
  userId, the owner of the task. This can be null if the task is not assigned to anyone.
  """
  userId: ID
  """
  When provided, the task is simultaneously pushed to an external project management service
  (e.g. GitHub, GitLab, Jira) at creation time. The viewer must have a valid OAuth integration
  with the service. If the external call fails, the entire mutation returns an error and no task
  is persisted locally.
  """
  integration: CreateTaskIntegrationInput
}

"""
Specifies which external project or repository a newly created Parabol task should be pushed to as
an issue/work-item. Used as the optional `integration` field on CreateTaskInput when calling the
`createTask` mutation, and also accepted directly by the `createTaskIntegration` mutation to link
an existing task that has no integration yet.

The caller must have a valid OAuth token for the target service (stored via the team's integration
settings). If neither the viewer nor the task assignee has an active token, the mutation returns an
error. Providing this input when the task already has an integration also returns an error.

Success: the external issue is created, the Task record is updated with an `integrationHash` and
`integration` sub-object, and a TaskSubscription notification is published to all team members.
"""
input CreateTaskIntegrationInput {
  """
  The external service where the issue should be created. Must match one of the configured
  integration providers for the team. Determines how `serviceProjectHash` is interpreted and which
  OAuth credentials are used.
  """
  service: TaskServiceEnum!
  """
  A service-specific identifier for the project or repository that will own the new issue.
  The required format differs by service:
  - github:      "owner/repo"  (nameWithOwner, e.g. "ParabolInc/parabol")
  - jira:        "cloudId:projectKey"  (e.g. "abc123:ENG")
  - jiraServer:  service-specific composite key for the Jira Server project
  - gitlab:      full project path (e.g. "group/subgroup/project")
  - azureDevOps: IntegrationRepoId composite (instanceId:projectId)
  - linear:      Linear team/project identifier
  Passing an unrecognised format for the selected service will cause task creation to fail.
  """
  serviceProjectHash: String!
}

"""
Payload returned by the createTaskIntegration mutation, which pushes an existing Parabol task to
an external issue tracker (e.g. Jira, GitHub) and links the two records together.

Success: error is null and task reflects the newly linked external issue (task.integration is
populated with the service-specific data and task.integrationHash is set).

Failure: error is non-null and task is null. Common failure reasons include: task not found,
task is already linked to an external service, neither the viewer nor the assignee has an active
auth token for the requested integration, or the external service call itself failed.
"""
type CreateTaskIntegrationPayload {
  """
  Present when the mutation failed. Describes why the task could not be pushed to the external
  integration (e.g. missing auth, task already linked, downstream API error).
  """
  error: StandardMutationError
  """
  The Parabol task after it has been successfully linked to the external issue. Contains the
  updated integration metadata (integrationHash, integration service details) returned by the
  external provider. Null when error is non-null.
  """
  task: Task
}

"""
Returned by the createTask mutation. On success, contains the newly created
task and any involvement notifications that were generated. On failure,
contains a StandardMutationError and null task/notification fields.

Success conditions: the viewer is a member of the target team, the optional
meetingId belongs to a meeting the viewer is currently in, the optional
discussionId is valid and belongs to the same meeting and team, and the
optional userId (assignee) is a member of the same team.

Failure conditions: viewer is not on the team, meetingId refers to a meeting
the viewer has not joined, discussionId is inconsistent with the meetingId or
teamId, the assignee userId is not a team member, or the optional integration
(e.g. GitHub/GitLab/Jira) fails to create a linked issue.

Subscription channels: the payload is also published via the TASK subscription
channel to all team members (excluding private tasks) and via the NOTIFICATION
channel to any user who was assigned or mentioned in the task content.
"""
type CreateTaskPayload {
  """
  Present when the mutation fails. Contains a human-readable message describing
  why the task could not be created (e.g. permission error, invalid meeting,
  integration failure).
  """
  error: StandardMutationError
  """The newly created task. Null when error is present."""
  task: Task
  """
  A notification sent to the assigned user or any user mentioned in the task
  content, indicating they are now involved with this task. Null when no such
  involvement notification was triggered (e.g. the creator assigned it to
  themselves, or the task has no assignee and no mentions).
  """
  involvementNotification: NotifyTaskInvolves
}

"""
Safe, display-only summary of a credit card on file for an organization, sourced from Stripe.

Returned on `Organization.creditCard` when the org has an active paid subscription with a saved
payment method. The field is null when the org is on a free plan or has no card on file.

To update the card, call the `updateCreditCard` mutation (requires `ORGS_WRITE` scope / billing
leader role), passing the Stripe `paymentMethodId` obtained from the client-side Stripe Elements
flow. On success, `UpdateCreditCardSuccess` returns the updated `Organization` (with a fresh
`CreditCard` here) plus a `stripeSubscriptionClientSecret` for confirming the payment intent.

No sensitive data (full card number, CVV) is ever stored or returned — only the brand, expiry,
and last four digits needed to identify the card to the user.
"""
type CreditCard {
  """The brand of the credit card, as provided by stripe"""
  brand: String!
  """The MM/YY string of the expiration date"""
  expiry: String!
  """The last 4 digits of a credit card"""
  last4: String!
}

"""
An ISO 8601 UTC datetime scalar. Serialized as a string in the format
`YYYY-MM-DDTHH:MM:SS.SSSZ` (e.g. `"2024-03-15T14:30:00.000Z"`), which is
the output of JavaScript's `Date.prototype.toJSON()`.

**Sending a DateTime to the server (inputs/variables):** pass an ISO 8601
string. The value must round-trip through `new Date(value).toJSON()` — in
practice this means a full UTC timestamp such as `"2024-03-15T14:30:00.000Z"`
or a date-only prefix like `"2024-03-15"` whose expansion starts with the
supplied string. Partial strings that do not satisfy this check are rejected.

**Receiving a DateTime from the server (query results):** the value is always
a full UTC timestamp string in the form `YYYY-MM-DDTHH:MM:SS.SSSZ`, safe to
pass directly to `new Date()`.
"""
scalar DateTime

"""
Return type for the deleteComment mutation. Resolves to DeleteCommentSuccess on success
or ErrorPayload when the operation fails.

Common error cases:
- The comment does not exist or is no longer active
- The commentId does not belong to the specified meetingId
- The viewer is not the author of the comment (only the original author or Parabol AI comment owners may delete)
- The viewer is not a member of the meeting (enforced by the @scope directive)
"""
union DeleteCommentPayload = ErrorPayload | DeleteCommentSuccess

"""
Returned by the deleteComment mutation when the comment is successfully soft-deleted.
The comment record is retained so that reply threading is preserved, but its content
is replaced with tombstone text and isActive is set to false on the Comment object.

Mutation signature:
  deleteComment(commentId: ID!, meetingId: ID!): DeleteCommentPayload!

Success conditions:
  - The comment exists and is still active (isActive true).
  - The comment belongs to a discussion whose meetingId matches the supplied meetingId.
  - The viewer is the comment author, OR the comment was posted by the Parabol AI user.

Failure conditions (returns ErrorPayload instead):
  - Comment does not exist or was already deleted.
  - The comment's discussion is not associated with the provided meetingId.
  - The viewer is not the comment author and the comment was not posted by the Parabol AI.

A DeleteCommentSuccess message is also broadcast on the MEETING subscription channel so
all participants in the meeting receive the update in real time.
"""
type DeleteCommentSuccess {
  """
  The ID of the comment that was deleted. Use this to remove or tombstone the comment
  in client-side caches and optimistic updates without needing to read the full Comment object.
  """
  commentId: ID!
  """
  The full Comment object as it exists after deletion. isActive will be false and content
  will contain tombstone placeholder text. Replies and other metadata are preserved.
  """
  comment: Comment!
}

"""
Returned by the deleteOAuthAPIProvider mutation after an OAuth API provider is
permanently removed from an organization.

Use this mutation to delete a provider that was previously created for
machine-to-machine OAuth flows. Requires the ORGS_WRITE scope.

Success: deletedProviderId is populated with the opaque client-side ID of the
removed provider so the caller can evict it from any local cache or list.

Failure: a GraphQL error is thrown (not returned as a field) when the provider
does not exist or cannot be found, e.g. "Provider not found".
"""
type DeleteOAuthAPIProviderPayload {
  """
  The opaque client-side ID of the OAuth API provider that was deleted.
  Use this to remove the provider from any locally cached list or relay store.
  Matches the providerId argument passed to the mutation.
  """
  deletedProviderId: ID!
}

"""
Payload returned by the deleteTask mutation. Permanently removes a task record
from the database (hard delete — not an archive or soft-delete). On success,
task is populated with the deleted task's data and the deletion is broadcast via
the TASK subscription channel to all team members who had visibility of the task
(private tasks are only broadcast to the task owner). On failure, error is set
and task is null.
"""
type DeleteTaskPayload {
  """
  Present when the mutation fails. Common reasons: the requested task does not
  exist or the caller does not have permission to delete it.
  """
  error: StandardMutationError
  """
  The task that was deleted, returned so clients can optimistically remove it
  from local caches or subscription listeners. Null when an error occurred.
  """
  task: Task
}

"""
Returned by the deleteUser mutation. Represents the outcome of a request to
permanently soft-delete a user account. A successful deletion removes the user
from all teams and organizations, blacklists their JWT, clears their auth
cookie (when a user deletes their own account), and broadcasts a mention update
to replace any in-progress references to that user. On success all fields are
null. On failure only error is populated.
"""
type DeleteUserPayload {
  """
  Populated when the mutation fails. Common failure reasons: supplying both
  userId and email (mutually exclusive), supplying neither, attempting to
  delete a different user without super-user privileges, or calling the
  mutation outside the re-authentication window required for self-deletion.
  Null on success.
  """
  error: StandardMutationError
}

"""
Payload returned by the denyPushInvitation mutation.

A push invitation is a request made by a user to join a team without a direct invite link.
Team members can approve or deny these requests. This payload is returned when a team member
denies such a request, incrementing the denial count on the PushInvitation record and
broadcasting the result via the TEAM subscription channel.

Success: teamId and userId are both present and error is null.
Failure: error is set and teamId/userId may be null. Common failure cases include:
  - The caller is not a member of the specified team.
  - No pending push invitation exists from the specified user to the specified team.
"""
type DenyPushInvitationPayload {
  error: StandardMutationError
  """
  The ID of the team to which the push invitation was denied.
  Present on success; used by subscribers to identify which team's invitation list changed.
  """
  teamId: ID
  """
  The ID of the user whose push invitation was denied.
  Present on success; identifies the user who will not be added to the team.
  """
  userId: ID
}

"""
Pushed via the notificationSubscription to all team members when a user's last
WebSocket connection closes. This is not the result of a mutation — the server
emits it automatically from the onDisconnect handler once it confirms the user
has no remaining open sockets (socketCount === 0). Subscribers use this payload
to update presence indicators, e.g. marking the user as offline in the UI.

Success: user is present and reflects the now-disconnected user.
No-op / not emitted: if the user still has other open connections (e.g. multiple
browser tabs), the payload is suppressed and presence is unchanged.
"""
type DisconnectSocketPayload {
  """
  The user who just fully disconnected (all sockets closed). Use this to update
  presence state — the user should be treated as offline after receiving this payload.
  """
  user: User
}

"""
A phase in a retrospective meeting where the team discusses the top-voted reflection groups one at a time.
This is the final structured phase of a retro — after grouping and voting, the team works through each
discussion topic in priority order. Each topic gets its own RetroDiscussStage, and the facilitator
advances through them sequentially. Use this type to render the discuss phase UI, navigate between
discussion topics, or inspect which topics remain.
"""
type DiscussPhase implements NewMeetingPhase {
  """Unique identifier for this phase instance (shortid)"""
  id: ID!
  """The ID of the retrospective meeting this discuss phase belongs to"""
  meetingId: ID!
  """The ID of the team running this meeting"""
  teamId: ID!
  """The type of phase — always "discuss" for this type"""
  phaseType: NewMeetingPhaseTypeEnum!
  """
  Ordered list of discussion stages, one per top-voted reflection group. Each stage represents a
  single topic the team will discuss. Stages are sorted by vote count (highest first) so the most
  important topics are discussed while energy is highest.
  """
  stages: [RetroDiscussStage!]!
}

"""
A threaded discussion attached to a specific topic within a meeting. Each Discussion belongs to
one meeting and one topic (e.g. a retro reflection group, an agenda item, or an issue from an
integration like GitHub or Jira). It acts as the container for all comments and tasks created
during that conversation. Use this type to render the comment thread UI, show participant
activity, and paginate thread items for a given topic.
"""
type Discussion {
  """The unique identifier for this discussion thread."""
  id: ID!
  """The ID of the team that owns the meeting this discussion belongs to."""
  teamId: ID!
  """The team that owns the meeting this discussion belongs to."""
  team: Team!
  """The ID of the meeting in which this discussion takes place."""
  meetingId: ID!
  """The timestamp when this discussion thread was created."""
  createdAt: DateTime!
  """
  The ID of the entity being discussed. The meaning depends on discussionTopicType — for example,
  an AgendaItem ID, a RetroReflectionGroup ID, a Task ID, or an external issue ID from an
  integration such as GitHub or Jira.
  """
  discussionTopicId: ID!
  """
  The type of entity being discussed, used together with discussionTopicId to resolve the actual
  topic object. Possible values include agendaItem, reflectionGroup, task, githubIssue, jiraIssue,
  and teamPromptResponse.
  """
  discussionTopicType: DiscussionTopicTypeEnum!
  """
  The meeting stage associated with this discussion, if the meeting is currently on that stage.
  Null when the meeting has not yet reached this topic's stage or the stage cannot be determined.
  """
  stage: NewMeetingStage
  """The total number of comments posted in this discussion thread."""
  commentCount: Int!
  """
  The list of users who are currently composing a comment in this discussion. Use this to render
  a live "someone is typing…" indicator.
  """
  commentors: [User!]!
  """
  A paginated connection containing the comments and tasks that make up this discussion thread,
  ordered by their sort position. Use first/after for cursor-based pagination.
  """
  thread(
    """
    The maximum number of thread items to return in a single page. Omit to fetch all items when
    only comments are needed and volume is expected to be small.
    """
    first: Int
    """
    The cursor (incrementing sort order value as a string) to start paging from, enabling
    forward pagination through the thread.
    """
    after: String
  ): ThreadableConnection!
}

"""
Interface implemented by every meeting stage that hosts a live discussion thread.
Any stage that lets participants post comments and tasks during a meeting implements this interface.

Concrete implementations (and the meeting type each belongs to):
- RetroDiscussStage — Retrospective meeting, Discuss phase. One stage per voted-on reflection group.
- EstimateStage — Sprint Poker meeting, Estimate phase. One stage per task being pointed.
- AgendaItemsStage — Check-In meeting, AgendaItems phase. One stage per agenda item.
- TeamPromptResponseStage — Standup (Team Prompt) meeting, Responses phase. One stage per team member.

When querying a stage, check for this interface to determine whether a discussion thread is available.
Use discussionId as the stable key for subscriptions, mutations (e.g. createComment, editComment),
and any other operation that targets a specific thread.
"""
interface DiscussionThreadStage {
  """
  The ID of the Discussion record that holds the comment and task thread for this stage.
  Use this as the key when subscribing to thread updates or when calling mutations that
  operate on a discussion (e.g. createComment, deleteComment, editComment).
  Each stage has exactly one discussion; the ID is stable for the lifetime of the stage.
  """
  discussionId: ID!
  """
  The Discussion object containing the full comment and task thread for this stage,
  including commentCount, active commentors, and the paginated thread connection.
  Prefer this over discussionId when you need to read thread data rather than just reference it.
  """
  discussion: Discussion!
}

"""
Identifies the type of entity that is the subject of a Discussion thread. Each Discussion belongs
to exactly one meeting and one topic entity. The topic type determines which meeting phase owns
the discussion and how the discussionTopicId foreign key should be resolved.
"""
enum DiscussionTopicTypeEnum {
  """
  An agenda item in an Action (check-in) meeting. The discussionTopicId references an AgendaItem.
  One discussion is created per agenda item stage when the team works through the agenda.
  """
  agendaItem
  """
  A reflection group (theme) in the Discuss phase of a Retrospective meeting. The discussionTopicId
  references a RetroReflectionGroup. One discussion is created per group so the team can comment
  and create tasks around each theme.
  """
  reflectionGroup
  """
  A Parabol task being estimated in a Sprint Poker meeting. The discussionTopicId references a Task.
  Used when the item being pointed is a native Parabol task rather than an external issue.
  """
  task
  """
  A GitHub issue being estimated in a Sprint Poker meeting. The discussionTopicId references a
  GitHub issue. Used when the item pulled into the Estimate phase originates from GitHub.
  """
  githubIssue
  """
  A Jira issue being estimated in a Sprint Poker meeting. The discussionTopicId references a
  Jira issue. Used when the item pulled into the Estimate phase originates from Jira.
  """
  jiraIssue
  """
  A team member's standup response in a Team Prompt (async standup) meeting. The discussionTopicId
  references a TeamMember. One discussion is created per team member so others can reply to that
  person's update.
  """
  teamPromptResponse
}

"""
The result of the dismissNewFeature mutation, which clears the new-feature
announcement for the authenticated user by setting their newFeatureId to null.
"""
type DismissNewFeaturePayload {
  """Present when the dismissal failed; null on success."""
  error: StandardMutationError
}

"""
The payload returned after a user dismisses a suggested action, removing it from their list of suggested next steps.
"""
type DismissSuggestedActionPayload {
  """Present if an error occurred during the mutation; null on success."""
  error: StandardMutationError
  """The user that dismissed the action"""
  user: User
  """The id of the removed suggested action"""
  removedSuggestedActionId: ID
}

"""
A request submitted by a user to join an organization whose activeDomain matches
the domain of their email address. Team leads in that organization receive a
notification and can accept the request via acceptRequestToJoinDomain, which adds
the requester to one or more of their teams. Requests expire after 30 days and are
deduplicated per (createdBy, domain) pair.
"""
type DomainJoinRequest {
  """
  A globally unique opaque identifier for this join request, prefixed for use as a GraphQL ID.
  Derived from the underlying integer primary key via DomainJoinRequestId.
  """
  id: ID!
  """The user ID of the person who submitted the join request."""
  createdBy: ID!
  """
  The email address of the user who submitted the join request, resolved from createdBy.
  """
  createdByEmail: String!
  """
  The lowercase email domain (e.g. "acme.com") that this request targets.
  Only organizations whose activeDomain matches this value are eligible to accept the request.
  """
  domain: String!
  """
  The teams the viewing user leads that belong to organizations whose activeDomain matches
  the request domain. These are the teams the viewer may add the requester to when
  calling acceptRequestToJoinDomain.
  """
  teams: [Team!]!
}

"""
Payload returned by the downgradeToStarter mutation. Transitions an organization
from a paid tier (Team or Enterprise) back to the free Starter tier. On success,
organization reflects the updated billing tier and teams contains each team
belonging to the org with any paid-only features reverted. On failure, error is
set and organization and teams are null.
"""
type DowngradeToStarterPayload {
  """
  Present when the mutation fails. Common reasons: the organization does not
  exist, is already on the Starter tier, or the caller lacks billing-admin
  permissions for the organization.
  """
  error: StandardMutationError
  """
  The organization after the downgrade, with its tier updated to Starter and
  billing details cleared. Null when an error occurred.
  """
  organization: Organization
  """
  All teams belonging to the organization, updated to reflect the removal of
  paid-only features (e.g. reduced member limits, disabled integrations).
  Null when an error occurred.
  """
  teams: [Team]
}

"""
The result of dragging a discussion topic to a new position in a retrospective meeting's discuss phase.
"""
type DragDiscussionTopicPayload {
  error: StandardMutationError
  """The meeting whose discuss-phase stage order was updated."""
  meeting: NewMeeting
  """The discuss stage that was repositioned."""
  stage: RetroDiscussStage
}

"""
The result of reordering a task within the estimate phase of a Poker meeting.
Returns an error if the meeting is not found, has already ended, or the requested position is out of range.
"""
union DragEstimatingTaskPayload = ErrorPayload | DragEstimatingTaskSuccess

"""
Returned when a task is successfully reordered in the estimating sidebar of a Poker meeting.
Contains the affected meeting and the full ordered list of estimate stages after the drag.
"""
type DragEstimatingTaskSuccess {
  """The ID of the Poker meeting in which the task was reordered"""
  meetingId: ID!
  """The Poker meeting in which the task was reordered"""
  meeting: PokerMeeting!
  """
  The ordered IDs of all estimate stages in the meeting after the reorder
  """
  stageIds: [ID!]!
  """
  The ordered list of all estimate stages in the meeting after the reorder
  """
  stages: [EstimateStage!]!
}

"""
The possible drop targets when a user drags a reflection card during a retrospective meeting. Determines whether the card is merged into an existing group or placed as a standalone card on the open board.
"""
enum DragReflectionDropTargetTypeEnum {
  """
  The reflection was dropped onto an existing reflection group, merging it into that group
  """
  REFLECTION_GROUP
  """
  The reflection was dropped onto the open grid (board), creating or remaining as a standalone group
  """
  REFLECTION_GRID
}

"""
The result of the editCommenting mutation, which tracks whether a user has started or stopped actively typing a comment in a discussion thread. Returns the affected discussion on success so subscribers can update the live typing-indicator state.
"""
union EditCommentingPayload = ErrorPayload | EditCommentingSuccess

"""
Returned when a user successfully broadcasts that they started or stopped typing a comment in a discussion
"""
type EditCommentingSuccess {
  """The ID of the discussion where the commenting state changed"""
  discussionId: ID!
  """The discussion where the commenting state changed"""
  discussion: Discussion!
}

"""Return value for editPageContent mutation"""
type EditPageContentSuccess {
  """The updated page"""
  page: Page!
}

"""
Payload returned when a participant starts or stops editing a reflection card during the reflect phase of a retrospective meeting. Broadcast to all meeting subscribers so clients can show real-time editing indicators.
"""
type EditReflectionPayload {
  error: StandardMutationError
  """
  The ID of the reflect prompt (column/category) whose reflection card is being edited.
  """
  promptId: ID
  """
  The socketId of the client editing the card (uses socketId to maintain anonymity)
  """
  editorId: ID
  """true if the reflection is being edited, else false"""
  isEditing: Boolean
}

"""
Payload for the editTask mutation. Broadcast to team members when a user starts or stops editing a task, enabling real-time presence indicators on task cards.
"""
type EditTaskPayload {
  error: StandardMutationError
  """The task being edited."""
  task: Task
  """The user who started or stopped editing the task."""
  editor: User
  """true if the editor is editing, false if they stopped editing"""
  isEditing: Boolean
}

"""
A valid email address string (e.g. "user@example.com").
Conforms to RFC 5322. Used for user identity, notifications, and authentication.
Stored and compared case-insensitively; always serialized in lowercase.
"""
scalar Email

"""
The result of the emailPasswordReset mutation. On success, returns EmailPasswordResetSuccess
indicating that a password-reset email has been dispatched to the provided address. On failure,
returns ErrorPayload with a human-readable message (e.g. unknown email address, rate-limited).
"""
union EmailPasswordResetPayload = ErrorPayload | EmailPasswordResetSuccess

"""
Return value for the emailPasswordReset mutation. Indicates whether a
password-reset email was successfully dispatched to the requested address.
"""
type EmailPasswordResetSuccess {
  """True if the email password reset was successfully sent"""
  success: Boolean
}

"""
The type of content that has been embedded for semantic search and retrieval.
Each value corresponds to a distinct domain object whose text is vectorized and indexed.
"""
enum EmbeddingTypeEnum {
  """
  A rich-text wiki page owned by a team or organization. Pages are embedded as
  they are created and updated via the Hocus Pocus collaboration server, and are
  searched using RBAC-based access rather than team-scoped EmbeddingsMetadata.
  """
  page
  """
  A meeting template (reflect, poker, check-in, etc.) whose name, prompts, and
  description are embedded so users can discover relevant templates via semantic
  search. Embeddings are updated whenever a template is renamed or modified.
  """
  meetingTemplate
  """
  A discussion topic from a retrospective meeting (a reflect-phase grouping of
  reflection cards that was discussed during the meeting). The full text of the
  topic and its cards is embedded to support post-meeting search and retrieval.
  These records are never updated after creation, so searches always filter on
  refUpdatedAt rather than a mutable updatedAt field.
  """
  retrospectiveDiscussionTopic
}

"""
A lightweight emoji reaction aggregate attached to an item. Each instance represents one
distinct emoji that has been reacted with, along with how many times it was used. Similar
to Reactji but without the per-user details — use this when you only need the reaction
counts, not which specific users reacted.
"""
type Emoji {
  """
  The emoji identifier, typically the shortcode name (e.g. "thumbsup" or "heart"). Use
  this to look up the rendered glyph or image for display in a reaction bar.
  """
  id: ID!
  """
  The total number of times this emoji has been reacted with on the parent item.
  """
  count: Int!
}

"""
The result of ending a check-in (Action) meeting. Returns either a successful outcome or an error.
"""
union EndCheckInPayload = ErrorPayload | EndCheckInSuccess

"""
Returned when a check-in (Action) meeting is successfully ended. Contains the final state of the
meeting, the team, any task changes that occurred, and a timeline event for the viewer's activity feed.
"""
type EndCheckInSuccess {
  """true if the meeting was killed (ended before reaching last stage)"""
  isKill: Boolean!
  """The team that ran the check-in meeting"""
  team: Team!
  """The check-in meeting that was ended"""
  meeting: ActionMeeting!
  """The ID of the suggestion to try a check-in meeting, if tried"""
  removedSuggestedActionId: ID
  """
  IDs of tasks that were deleted when the meeting ended, such as private tasks belonging to members who left the team
  """
  removedTaskIds: [ID!]
  """
  The timeline event created for this ended meeting, surfaced in the viewer's activity feed
  """
  timelineEvent: TimelineEvent!
  """IDs of tasks that were updated during the meeting"""
  updatedTaskIds: [ID!]
  """Any tasks that were updated during the meeting"""
  updatedTasks: [Task!]
}

"""
The payload returned after a team member stops dragging a reflection card during a retrospective meeting.
Describes where the reflection landed, which groups were affected, and who performed the drag.
"""
type EndDraggingReflectionPayload {
  error: StandardMutationError
  """
  The unique identifier for this drag interaction, used to correlate start and end drag events
  """
  dragId: ID
  """The drag as sent from the team member"""
  remoteDrag: RemoteReflectionDrag
  """the type of item the reflection was dropped on"""
  dropTargetType: DragReflectionDropTargetTypeEnum
  """
  The ID that the dragged item was dropped on, if dropTargetType is not specific enough
  """
  dropTargetId: ID
  """The retrospective meeting in which the drag occurred"""
  meeting: RetrospectiveMeeting
  """The ID of the retrospective meeting in which the drag occurred"""
  meetingId: ID
  """The reflection card that was dragged and dropped"""
  reflection: RetroReflection
  """
  The ID of the reflection group the reflection now belongs to after being dropped
  """
  reflectionGroupId: ID
  """The ID of the reflection card that was dragged"""
  reflectionId: ID
  """foreign key to get user"""
  userId: ID
  """
  The group encapsulating the new reflection. A new one was created if one was not provided.
  """
  reflectionGroup: RetroReflectionGroup
  """The old group the reflection was in"""
  oldReflectionGroup: RetroReflectionGroup
}

"""
The result of ending a retrospective meeting. Returns either a success payload with the concluded meeting details or an error describing why the operation failed.
"""
union EndRetrospectivePayload = ErrorPayload | EndRetrospectiveSuccess

"""
The result of successfully ending a retrospective meeting. Contains the final
state of the meeting, the team it belonged to, any cleanup side-effects (removed
tasks and suggested actions), and a timeline event surfaced to the viewer.
"""
type EndRetrospectiveSuccess {
  """
  True if the meeting was force-ended (killed) before reaching the last stage; false if it completed normally through all stages.
  """
  isKill: Boolean!
  """The team that hosted the retrospective meeting"""
  team: Team!
  """
  The retrospective meeting that was ended, including all phases, reflections, and action items
  """
  meeting: RetrospectiveMeeting!
  """
  The ID of the suggested action to try a retrospective meeting that was removed because the meeting was completed, if one existed.
  """
  removedSuggestedActionId: ID
  """
  IDs of tasks that were removed as part of ending the meeting (e.g. orphaned tasks with no assignee)
  """
  removedTaskIds: [ID!]!
  """
  IDs of tasks that were updated when the meeting ended (e.g. Done tasks archived because the Review Tasks phase ran)
  """
  updatedTaskIds: [ID!]
  """
  The timeline event created for this ended meeting, surfaced in the viewer's activity feed.
  """
  timelineEvent: TimelineEvent!
}

"""
The result of the endSprintPoker mutation. Returns EndSprintPokerSuccess on success,
or ErrorPayload if the meeting was not found, was already ended, or the caller lacks permission.
"""
union EndSprintPokerPayload = ErrorPayload | EndSprintPokerSuccess

"""
The successful result of ending a Sprint Poker meeting, including the final meeting state,
affected tasks, and a timeline event for the viewer's activity feed.
"""
type EndSprintPokerSuccess {
  """true if the meeting was killed (ended before reaching last stage)"""
  isKill: Boolean!
  """The ID of the Sprint Poker meeting that was ended."""
  meetingId: ID!
  """The Sprint Poker meeting that was ended, with its final state."""
  meeting: PokerMeeting!
  """
  IDs of tasks that were removed when the meeting ended (e.g. tasks with no story points assigned).
  """
  removedTaskIds: [ID!]!
  """The team that hosted the Sprint Poker meeting."""
  team: Team!
  """The ID of the team that hosted the Sprint Poker meeting."""
  teamId: ID!
  """An event that is important to the viewer, e.g. an ended meeting"""
  timelineEvent: TimelineEvent!
}

"""
The result of ending a Team Prompt (async standup) meeting. Returns either a success object with the
finalized meeting data or an error if the meeting could not be ended (e.g. meeting not found,
caller lacks permission, or meeting is already ended).
"""
union EndTeamPromptPayload = ErrorPayload | EndTeamPromptSuccess

"""
The payload returned when a Team Prompt meeting is successfully ended.
Contains the updated meeting, its ID, the team it belongs to, and the
timeline event created to record the meeting's completion.
"""
type EndTeamPromptSuccess {
  """The Team Prompt meeting that was ended, with its final state."""
  meeting: TeamPromptMeeting!
  """The ID of the Team Prompt meeting that was ended."""
  meetingId: ID!
  """The team that owns the ended meeting."""
  team: Team!
  """An event that is important to the viewer, e.g. an ended meeting"""
  timelineEvent: TimelineEvent!
}

"""
Returned by mutations when an error prevents the operation from completing successfully. When present, the client should surface the error details to the user rather than attempting to process any other payload fields.
"""
type ErrorPayload {
  """Structured error information describing why the mutation failed."""
  error: StandardMutationError!
}

"""
The phase in a Sprint Poker meeting where the team collectively estimates the effort or complexity
of each task, one at a time. Each task gets its own EstimateStage, where participants privately
select a score from a template dimension (e.g. story points), then reveal votes simultaneously
to spark discussion. The facilitator moves through stages sequentially and sets a final score for
each task before advancing. Use this type to render the estimation phase UI, iterate over tasks
being estimated, or inspect scoring progress.
"""
type EstimatePhase implements NewMeetingPhase {
  """Unique identifier for this phase instance (shortid)"""
  id: ID!
  """The ID of the Sprint Poker meeting this estimate phase belongs to"""
  meetingId: ID!
  """The ID of the team running this meeting"""
  teamId: ID!
  """The type of phase — always "ESTIMATE" for this type"""
  phaseType: NewMeetingPhaseTypeEnum!
  """
  Ordered list of estimation stages, one per task being estimated. Each stage contains the
  scoring state for a single task, including participant votes and the final score set by
  the facilitator.
  """
  stages: [EstimateStage!]!
}

"""
A stage within a Sprint Poker meeting where the team estimates and discusses a single task (Parabol Task or linked integration issue). Each stage is tied to one dimension (e.g. Story Points) and one task, and progresses from active voting to revealed scores to a facilitator-chosen final score.
"""
type EstimateStage implements NewMeetingStage & DiscussionThreadStage {
  """The unique stage ID (shortid)"""
  id: ID!
  """
  The datetime the stage was completed (facilitator clicked 'Done'), null while still in progress
  """
  endAt: DateTime
  """
  Foreign key for the Sprint Poker meeting this stage belongs to. Prefer the meeting field for full details.
  """
  meetingId: ID!
  """The Sprint Poker meeting this stage belongs to"""
  meeting: NewMeeting!
  """
  True if the facilitator has marked this stage complete (equivalent to endAt being set)
  """
  isComplete: Boolean!
  """
  True if any meeting participant is allowed to navigate directly to this stage
  """
  isNavigable: Boolean!
  """True if the facilitator is allowed to navigate directly to this stage"""
  isNavigableByFacilitator: Boolean!
  """
  The phase this stage belongs to (e.g. the ESTIMATE phase of a Sprint Poker meeting)
  """
  phase: NewMeetingPhase
  """The type identifier of the phase this stage belongs to"""
  phaseType: NewMeetingPhaseTypeEnum
  """The datetime the facilitator first entered this stage"""
  startAt: DateTime
  """
  The number of times the facilitator has visited this stage during the meeting
  """
  viewCount: Int
  """
  True if a time limit is active and the stage is running asynchronously, false if a fixed end time is set, null if no time constraint is set
  """
  isAsync: Boolean
  """
  True if the current viewer has clicked Ready to advance to the next stage
  """
  isViewerReady: Boolean!
  """
  IDs of all team members who have clicked Ready to advance to the next stage
  """
  readyUserIds: [ID!]!
  """
  The datetime when this stage's time limit expires. Null if no time limit or end time has been set.
  """
  scheduledEndTime: DateTime
  """
  A system-suggested async deadline based on historical meeting data for this team. Null if insufficient data.
  """
  suggestedEndTime: DateTime
  """
  A system-suggested synchronous time limit (in minutes) based on historical meeting data for this team. Null if insufficient data.
  """
  suggestedTimeLimit: Float
  """
  The ID of the team running the Sprint Poker meeting that contains this stage
  """
  teamId: ID!
  """
  Milliseconds remaining until scheduledEndTime, calculated server-side to compensate for unsynchronized client clocks. Null if scheduledEndTime is null.
  """
  timeRemaining: Float
  """
  The 0-based position of this stage within its phase, ordered by sortOrder.
  """
  stageIdx: Int!
  """
  Foreign key linking to the Discussion thread associated with this stage
  """
  discussionId: ID!
  """
  The threaded discussion attached to this estimation stage, used for comments and reactions during estimation
  """
  discussion: Discussion!
  """
  The ID of the user who added this stage to the meeting (typically the facilitator or the user who added the task to the meeting)
  """
  creatorUserId: ID!
  """The ID of the Parabol Task being estimated in this stage"""
  taskId: ID!
  """
  The field on the external service (e.g. Jira story points field) that this dimension maps to, used to push the final score back to the integration
  """
  serviceField: ServiceField!
  """
  The zero-based index of the TemplateDimensionRef used for this stage. Immutable after stage creation.
  """
  dimensionRefIdx: Int!
  """
  A frozen snapshot of the template dimension (e.g. Story Points) used for this stage. Immutable so historical meetings are unaffected by template edits.
  """
  dimensionRef: TemplateDimensionRef!
  """
  The final score chosen by the facilitator after voting is revealed. Null until the facilitator selects a value.
  """
  finalScore: String
  """
  IDs of team members whose cursors are currently hovering over the card deck (used for live presence indicators)
  """
  hoveringUserIds: [ID!]!
  """
  User objects for team members whose cursors are currently hovering over the card deck
  """
  hoveringUsers: [User!]!
  """All vote scores submitted for this stage, one entry per user who voted"""
  scores: [EstimateUserScore!]!
  """
  The Parabol Task being estimated. Null if the task has been deleted since the stage was created.
  """
  task: Task
  """
  True while participants are actively voting and individual scores are hidden. False after the facilitator reveals all votes.
  """
  isVoting: Boolean!
}

"""
A single team member's vote on a Poker planning stage. Each stage corresponds to one
estimation dimension, so this record captures which label (e.g. "5", "XL") a specific
user chose when voting on that dimension. One score exists per (stage, user) pair.
"""
type EstimateUserScore {
  """
  A composite identifier derived from the stageId and userId, uniquely identifying this
  vote within the meeting.
  """
  id: ID!
  """
  The ID of the EstimateStage (i.e. the specific dimension being estimated) that this
  score belongs to.
  """
  stageId: ID!
  """The ID of the team member who cast this vote."""
  userId: ID!
  """The team member who cast this vote."""
  user: User!
  """
  The scale label selected by the user at the time of voting (e.g. "3", "8", "?").
  Stored as a snapshot because scale values are mutable — the label may no longer exist
  on the dimension's template scale after the vote was cast.
  """
  label: String!
}

"""
A server-side feature flag used to enable or disable functionality for specific users, teams, or organizations
"""
type FeatureFlag {
  """The ID of the feature flag"""
  id: ID!
  """The name of the feature flag"""
  featureName: String!
  """Description of the feature flag"""
  description: String
  """Expiration date of the feature flag"""
  expiresAt: DateTime!
  """The scope at which this flag applies: User, Team, or Organization"""
  scope: FeatureFlagScope!
}

"""
The entity (user, team, or organization) that a feature flag is applied to
"""
type FeatureFlagOwner {
  """The name of the feature flag"""
  featureName: String!
  """The user ID if the owner is a user"""
  userId: ID
  """The team ID if the owner is a team"""
  teamId: ID
  """The organization ID if the owner is an organization"""
  orgId: ID
}

"""The list of scopes available for feature flags"""
enum FeatureFlagScope {
  User
  Team
  Organization
}

"""A file buffer"""
scalar File

"""
An activity that does not have a customizable template, e.g. standup, check-in
"""
type FixedActivity implements MeetingTemplate {
  """The activity ID, one of: teamPrompt or action"""
  id: ID!
  """Date the activity was created"""
  createdAt: DateTime!
  """Always true"""
  isActive: Boolean!
  """Always true"""
  isFree: Boolean!
  """The time of the meeting the template was last used"""
  lastUsedAt: DateTime
  """The name of the template"""
  name: String!
  """The org ID for fixed activities (always a placeholder ghost org)"""
  orgId: ID!
  """Sharing scope for fixed activities (always public)"""
  scope: SharingScopeEnum!
  """The team ID for fixed activities (always a placeholder ghost team)"""
  teamId: ID!
  """The placeholder ghost team for fixed activities"""
  team: Team!
  """The meeting type, one of: teamPrompt or action"""
  type: MeetingTypeEnum!
  updatedAt: DateTime!
  """
  The category this template falls under, e.g. retro, feedback, strategy, etc.
  """
  category: String!
  """
  Whether this template should be in the recommended/quick start sections in the UI.
  """
  isRecommended: Boolean!
  """The url to the illustration used by the template"""
  illustrationUrl: String!
  """The lowest scope of the permissions available to the viewer"""
  viewerLowestScope: SharingScopeEnum!
}

"""Return object for FlagReadyToAdvancePayload"""
union FlagReadyToAdvancePayload = ErrorPayload | FlagReadyToAdvanceSuccess

"""
The result of flagging a participant as ready to advance to the next meeting stage
"""
type FlagReadyToAdvanceSuccess {
  """the meeting with the updated readyUserIds"""
  meeting: NewMeeting!
  """the stage with the updated readyUserIds"""
  stage: NewMeetingStage!
}

"""Integration Auth and shared providers available to the team member"""
type GcalIntegration {
  """The OAuth2 Authorization for this team member"""
  auth: TeamMemberIntegrationAuthOAuth2
  """
  The cloud provider the team member may choose to integrate with. Nullable based on env vars
  """
  cloudProvider: IntegrationProviderOAuth2
  """Events for specific time periods"""
  events(startDate: DateTime!, endDate: DateTime!): [GcalIntegrationEvent!]!
}

"""A Google Calendar event returned as part of a GcalIntegration query"""
type GcalIntegrationEvent {
  """The event title or subject"""
  summary: String
  """The start date and time of the event"""
  startDate: DateTime
  """The end date and time of the event"""
  endDate: DateTime
  """A URL link to the event in Google Calendar"""
  link: String
  """The physical or virtual location of the event, if any"""
  location: String
  """The number of people invited to the event, including the viewer"""
  attendeeCount: Int
}

"""The type of video conferencing used in the gcal event"""
enum GcalVideoTypeEnum {
  meet
  zoom
}

"""
Google Drive integration info for a team member, used for Meet transcript imports
"""
type GdriveIntegration {
  """The OAuth2 access token for this integration, if connected"""
  auth: TeamMemberIntegrationAuthOAuth2
  """The global provider configuration for gdrive OAuth"""
  cloudProvider: IntegrationProviderOAuth2
  """True if the user has an active gdrive integration for this team"""
  isActive: Boolean!
  """The time the Google Drive watch channel expires, if one is active"""
  watchExpiresAt: DateTime
}

"""The success response needed by the meeting subscription"""
type GenerateGroupsSuccess {
  """The retrospective meeting with updated AI-generated reflection groups"""
  meeting: RetrospectiveMeeting!
}

"""
Parameters used to re-run a Your Work integration search server-side and generate
inspiration items from the matching work items.
"""
input GenerateInspirationItemsInput {
  """The meeting the items are being generated for"""
  meetingId: ID!
  """The integration service to pull work items from, e.g. github"""
  service: String!
  """
  The service-specific search string. For github, the same search string the client
  uses (including any date range filter and is:issue / is:pr qualifier)
  """
  searchQuery: String!
  """An optional custom prompt that overrides the default generation prompt"""
  userPrompt: String
}

"""
The result of successfully generating inspiration items from a user's recent work
"""
type GenerateInspirationItemsSuccess {
  """The generated inspiration items, 0 or more"""
  inspirationItems: [InspirationItem!]!
  """The meeting the items were generated for"""
  meeting: NewMeeting!
}

"""An all-purpose meeting phase with no extra state"""
type GenericMeetingPhase implements NewMeetingPhase {
  """The unique phase ID"""
  id: ID!
  """The meeting this phase belongs to"""
  meetingId: ID!
  """The team this phase belongs to"""
  teamId: ID!
  """The type of phase"""
  phaseType: NewMeetingPhaseTypeEnum!
  """The stages that make up this phase"""
  stages: [GenericMeetingStage!]!
}

"""
A stage of a meeting that has no extra state. Only used for single-stage phases
"""
type GenericMeetingStage implements NewMeetingStage {
  """The unique stage ID"""
  id: ID!
  """The datetime the stage was completed"""
  endAt: DateTime
  """The ID of the meeting this stage belongs to"""
  meetingId: ID!
  """The meeting this stage belongs to"""
  meeting: NewMeeting!
  """true if the facilitator has completed this stage, else false"""
  isComplete: Boolean!
  """true if any meeting participant can navigate to this stage"""
  isNavigable: Boolean!
  """true if the facilitator can navigate to this stage"""
  isNavigableByFacilitator: Boolean!
  """The phase this stage belongs to"""
  phase: NewMeetingPhase
  """The type of the phase"""
  phaseType: NewMeetingPhaseTypeEnum!
  """The datetime the stage was started"""
  startAt: DateTime
  """Number of times the facilitator has visited this stage"""
  viewCount: Int
  """
  true if a time limit is set, false if end time is set, null if neither is set
  """
  isAsync: Boolean
  """true if the viewer is ready to advance, else false"""
  isViewerReady: Boolean!
  """User ids of those who are ready to advance to the next stage"""
  readyUserIds: [ID!]!
  """
  The datetime the phase is scheduled to be finished, null if no time limit or end time is set
  """
  scheduledEndTime: DateTime
  """
  The suggested ending datetime for a phase to be completed async, null if not enough data to make a suggestion
  """
  suggestedEndTime: DateTime
  """
  The suggested time limit for a phase to be completed together, null if not enough data to make a suggestion
  """
  suggestedTimeLimit: Float
  """The team this stage belongs to"""
  teamId: ID!
  """
  The number of milliseconds left before the scheduled end time. Useful for unsynced client clocks. null if scheduledEndTime is null
  """
  timeRemaining: Float
  """
  The 0-based position of this stage within its phase, ordered by sortOrder.
  """
  stageIdx: Int!
}

"""Return value for getDemoGroupTitle, which could be an error"""
union GetDemoGroupTitlePayload = ErrorPayload | GetDemoGroupTitleSuccess

"""The AI-generated title for a demo reflection group"""
type GetDemoGroupTitleSuccess {
  """The suggested title for the reflection group"""
  title: String!
}

"""A response with info about a gif"""
type GifResponse {
  """The ID of the gif"""
  id: ID!
  """A description of the gif"""
  description: String!
  """A list of tags describing the gif"""
  tags: [String!]!
  """The URL of the gif at the requested size"""
  url(
    """The size of the gif"""
    size: ImageSize!
  ): String!
}

"""A connection to list the returned gifs"""
type GifResponseConnection {
  """Page info with cursors as strings"""
  pageInfo: PageInfo
  """A list of edges."""
  edges: [GifResponseEdge!]!
}

"""An edge in a connection."""
type GifResponseEdge {
  """The item at the end of the edge"""
  node: GifResponse!
  """Cursor for pagination"""
  cursor: String
}

"""
GitHub OAuth integration data for a team member, including access token and search query history
"""
type GitHubIntegration {
  """Composite key: userId:teamId"""
  id: ID!
  """The OAuth access token for GitHub API requests (non-expiring)"""
  accessToken: ID
  """The timestamp the provider was created"""
  createdAt: DateTime!
  """true if an access token exists, else false"""
  isActive: Boolean!
  """
  the list of suggested search queries, sorted by most recent. Guaranteed to be < 60 days old
  """
  githubSearchQueries: [GitHubSearchQuery!]!
  """The GitHub username used for API queries"""
  login: ID!
  """The comma-separated list of scopes requested from GitHub"""
  scope: String!
  """The team this integration is linked to"""
  teamId: ID!
  """The timestamp the token was updated at"""
  updatedAt: DateTime!
  """The user that the access token is attached to"""
  userId: ID!
}

"""
A GitHub search query including all filters selected when the query was executed
"""
type GitHubSearchQuery {
  """shortid"""
  id: ID!
  """
  The query string in GitHub format, including repository filters. e.g. is:issue is:open
  """
  queryString: String!
  """the time the search query was last used. Used for sorting"""
  lastUsedAt: DateTime!
}

"""Gitlab integration data for a given team member"""
type GitLabIntegration {
  """The OAuth2 Authorization for this team member"""
  auth: TeamMemberIntegrationAuthOAuth2
  """
  The cloud provider the team member may choose to integrate with. Nullable based on env vars
  """
  cloudProvider: IntegrationProviderOAuth2
  """The non-global providers shared with the team or organization"""
  sharedProviders: [IntegrationProviderOAuth2!]!
  """An historical list of GitLab Sprint Poker search queries"""
  gitlabSearchQueries: [GitLabSearchQuery!]!
  """A list of projects accessible by this team member"""
  projects: [RepoIntegration!]!
  projectsIssues(
    first: Int!
    """the stringified cursors for pagination"""
    after: String
    """the ids of the projects selected as filters"""
    projectsIds: [String]
    """the search query that the user enters to filter issues"""
    searchQuery: String!
    """the sort string that defines the order of the returned issues"""
    sort: String!
    """the state of issues, e.g. opened or closed"""
    state: String!
  ): GitLabIntegrationConnection!
}

"""A connection to a list of items."""
type GitLabIntegrationConnection {
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """A list of edges."""
  edges: [GitLabIntegrationEdge!]!
  """An error with the connection, if any"""
  error: StandardMutationError
}

"""An edge in a connection."""
type GitLabIntegrationEdge {
  """The item at the end of the edge"""
  node: TaskIntegration!
  """Cursor for pagination"""
  cursor: String
}

"""
A GitLab search query including the search query and the project filters
"""
type GitLabSearchQuery {
  """shortid"""
  id: ID!
  """The query string used to search GitLab issue titles and descriptions"""
  queryString: String!
  """
  The list of ids of projects that have been selected as a filter. Null if none have been selected
  """
  selectedProjectsIds: [ID!]
  """the time the search query was last used. Used for sorting"""
  lastUsedAt: DateTime!
}

"""The result of completing the grouping phase in a retrospective meeting"""
type GroupPhaseCompletePayload {
  """a list of empty reflection groups to remove"""
  emptyReflectionGroupIds: [ID!]!
  """the current meeting"""
  meeting: RetrospectiveMeeting!
  """a list of updated reflection groups"""
  reflectionGroups: [RetroReflectionGroup]
}

"""The size of an image"""
enum ImageSize {
  """Less than 90px tall"""
  nano
  """Less than 220px tall"""
  tiny
  """full size"""
  original
}

"""The result of deactivating a user account"""
type InactivateUserPayload {
  """Error information if the mutation failed"""
  error: StandardMutationError
  """The user that has been inactivated"""
  user: User
}

"""
An AI-generated draft, grounded in a user's recent work items, that answers the
meeting prompt. The text is editable and can be moved into a meeting response.
"""
type InspirationItem {
  """A unique id for the item"""
  id: ID!
  """The editable AI-generated text (plaintext/markdown)"""
  content: String!
  """An optional short heading for the item"""
  title: String
  """The integration service the source work items came from, e.g. github"""
  service: String!
  """
  For retrospective meetings, the id of the ReflectPrompt (column) the item should be added to.
  Null for team prompt meetings, which have no reflect prompts.
  """
  promptId: ID
  """The time the item was generated"""
  createdAt: DateTime!
}

"""An authentication provider configuration"""
interface IntegrationProvider {
  """The provider's unique identifier"""
  id: ID!
  """The team that created the provider, null if not team scoped"""
  teamId: ID
  """The org that created the provider, null if not org scoped"""
  orgId: ID
  """The timestamp the provider was created"""
  createdAt: DateTime!
  """The timestamp the token was updated at"""
  updatedAt: DateTime!
  """The name of the integration service (GitLab, Mattermost, etc)"""
  service: IntegrationProviderServiceEnum!
  """The kind of token used by this provider (OAuth2, PAT, Webhook)"""
  authStrategy: IntegrationProviderAuthStrategyEnum!
  """
  The scope this provider configuration was created at (globally, org-wide, or by the team)
  """
  scope: IntegrationProviderScopeEnum!
  """true if the provider configuration should be used"""
  isActive: Boolean!
}

"""The kind of token provided by the service"""
enum IntegrationProviderAuthStrategyEnum {
  """OAuth 1.0 token-based authentication (e.g. Jira Server)"""
  oauth1
  """OAuth 2.0 token-based authentication (e.g. GitLab, Google Calendar)"""
  oauth2
  """Personal access token authentication"""
  pat
  """Outbound webhook with no inbound authentication"""
  webhook
  """Shared secret used to sign requests between Parabol and the provider"""
  sharedSecret
}

"""
The scope this provider was created on by a user (excluding global scope)
"""
enum IntegrationProviderEditableScopeEnum {
  org
  team
  global
}

"""OAuth1 provider metadata"""
input IntegrationProviderMetadataInputOAuth1 {
  """The base URL used to access the provider"""
  serverBaseUrl: URL!
  """The client key to give to the provider"""
  consumerKey: ID!
  """Secret or Private key of the generate private/public key pair"""
  consumerSecret: String!
}

"""OAuth2 provider metadata"""
input IntegrationProviderMetadataInputOAuth2 {
  """The base URL used to access the provider"""
  serverBaseUrl: URL!
  """The client id to give to the provider"""
  clientId: String!
  """The client secret to give to the provider"""
  clientSecret: String!
  """The tenant id to give to the provider"""
  tenantId: String
}

"""Shared secret provider metadata"""
input IntegrationProviderMetadataInputSharedSecret {
  """The base URL used to access the provider"""
  serverBaseUrl: URL!
  """Shared secret between Parabol and the provider"""
  sharedSecret: String!
}

"""Webhook provider metadata"""
input IntegrationProviderMetadataInputWebhook {
  """Webhook URL to be used by the provider"""
  webhookUrl: URL!
}

"""An integration provider that connects via OAuth1.0"""
type IntegrationProviderOAuth1 implements IntegrationProvider {
  """The provider's unique identifier"""
  id: ID!
  """The team that created the provider, null if not team scoped"""
  teamId: ID
  """The org that created the provider, null if not org scoped"""
  orgId: ID
  """The timestamp the provider was created"""
  createdAt: DateTime!
  """The timestamp the token was updated at"""
  updatedAt: DateTime!
  """The name of the integration service (GitLab, Mattermost, etc)"""
  service: IntegrationProviderServiceEnum!
  """The kind of token used by this provider (OAuth2, PAT, Webhook)"""
  authStrategy: IntegrationProviderAuthStrategyEnum!
  """
  The scope this provider configuration was created at (globally, org-wide, or by the team)
  """
  scope: IntegrationProviderScopeEnum!
  """true if the provider configuration should be used"""
  isActive: Boolean!
  """The base URL of the OAuth1 server"""
  serverBaseUrl: URL!
}

"""An integration provider that connects via OAuth2"""
type IntegrationProviderOAuth2 implements IntegrationProvider {
  """The provider's unique identifier"""
  id: ID!
  """The team that created the provider, null if not team scoped"""
  teamId: ID
  """The org that created the provider, null if not org scoped"""
  orgId: ID
  """The timestamp the provider was created"""
  createdAt: DateTime!
  """The timestamp the token was updated at"""
  updatedAt: DateTime!
  """The name of the integration service (GitLab, Mattermost, etc)"""
  service: IntegrationProviderServiceEnum!
  """The kind of token used by this provider (OAuth2, PAT, Webhook)"""
  authStrategy: IntegrationProviderAuthStrategyEnum!
  """
  The scope this provider configuration was created at (globally, org-wide, or by the team)
  """
  scope: IntegrationProviderScopeEnum!
  """true if the provider configuration should be used"""
  isActive: Boolean!
  """The base URL of the OAuth2 server"""
  serverBaseUrl: URL!
  """The OAuth2 client id"""
  clientId: ID!
  """The tenant ID for Azure Active Directory Auth"""
  tenantId: ID
}

"""
The scope this provider was created on (globally, org-wide, or on the team)
"""
enum IntegrationProviderScopeEnum {
  global
  org
  team
}

"""The name of the service of the Integration Provider"""
enum IntegrationProviderServiceEnum {
  """Atlassian Jira Cloud"""
  jira
  """GitHub"""
  github
  """GitLab"""
  gitlab
  """Mattermost messaging platform"""
  mattermost
  """Atlassian Jira Server (self-hosted)"""
  jiraServer
  """Google Calendar"""
  gcal
  """Microsoft Azure DevOps"""
  azureDevOps
  """Microsoft Teams"""
  msTeams
  """Linear issue tracker"""
  linear
  """Google Drive (Meet Recordings transcript import)"""
  gdrive
  """Zoom video conferencing (meeting transcript import)"""
  zoom
}

"""An integration provider that connects via webhook"""
type IntegrationProviderWebhook implements IntegrationProvider {
  """The provider's unique identifier"""
  id: ID!
  """The team that created the provider, null if not team scoped"""
  teamId: ID
  """The org that created the provider, null if not org scoped"""
  orgId: ID
  """The timestamp the provider was created"""
  createdAt: DateTime!
  """The timestamp the token was updated at"""
  updatedAt: DateTime!
  """The name of the integration service (GitLab, Mattermost, etc)"""
  service: IntegrationProviderServiceEnum!
  """The kind of token used by this provider (OAuth2, PAT, Webhook)"""
  authStrategy: IntegrationProviderAuthStrategyEnum!
  """
  The scope this provider configuration was created at (globally, org-wide, or by the team)
  """
  scope: IntegrationProviderScopeEnum!
  """true if the provider configuration should be used"""
  isActive: Boolean!
  """The webhook URL"""
  webhookUrl: URL!
}

"""
The result of invalidating all active sessions for a user, forcing them to log in again
"""
type InvalidateSessionsPayload {
  """Error information if the mutation failed"""
  error: StandardMutationError
}

"""The result of inviting one or more users to join a team"""
type InviteToTeamPayload {
  """Error information if the mutation failed"""
  error: StandardMutationError
  """The team the inviter is inviting the invitee to"""
  team: Team
  """A list of email addresses the invitations were sent to"""
  invitees: [Email!]
  """the notification ID if this payload is sent to a subscriber, else null"""
  teamInvitationNotificationId: ID
  """The notification sent to the invitee if they are a parabol user"""
  teamInvitationNotification: NotificationTeamInvitation
  """the `invite your team` suggested action that was removed, if any"""
  removedSuggestedActionId: ID
}

"""A monthly billing invoice for an organization"""
type Invoice {
  """A shortid for the invoice"""
  id: ID!
  """The datetime the invoice period has ended"""
  periodEndAt: DateTime!
  """The total amount for the invoice (in USD)"""
  total: Float!
  """The URL to pay via stripe if payment was not collected in app"""
  payUrl: String!
  """
  the status of the invoice. starts as pending, moves to paid or unpaid depending on if the payment succeeded
  """
  status: InvoiceStatusEnum!
}

"""A connection to a list of items."""
type InvoiceConnection {
  """Page info with cursors coerced to ISO8601 dates"""
  pageInfo: PageInfoDateCursor
  """A list of edges."""
  edges: [InvoiceEdge!]!
}

"""An edge in a connection."""
type InvoiceEdge {
  """The item at the end of the edge"""
  node: Invoice!
  """Cursor for date-based pagination"""
  cursor: DateTime
}

"""The payment status of the invoice"""
enum InvoiceStatusEnum {
  """Payment is being processed"""
  PENDING
  """Payment was successfully collected"""
  PAID
  """Payment attempt failed"""
  FAILED
  """Invoice for the current billing period, not yet due"""
  UPCOMING
}

"""
A Jira field to be displayed on the estimate header card along with its value.
"""
type JiraExtraField {
  """The ID of the field (e.g. 'customfield_1001')"""
  fieldId: String!
  """The human-readable name of the field (e.g. 'Acceptance Criteria')"""
  fieldName: String!
  """
  The type of the field as returned by Jira (e.g. 'number', 'string', 'option')
  """
  fieldType: String
  """The value of the field for the specific issue."""
  fieldValue: String
}

"""The Jira Issue that comes direct from Jira"""
type JiraIssue implements TaskIntegration {
  """GUID cloudId:issueKey"""
  id: ID!
  """The parabol teamId this issue was fetched for"""
  teamId: ID!
  """The parabol userId this issue was fetched for"""
  userId: ID!
  """The ID of the jira cloud where the issue lives"""
  cloudId: ID!
  """The name of the jira cloud where the issue lives"""
  cloudName: ID!
  """The url to access the issue"""
  url: String!
  """The key of the issue as found in Jira"""
  issueKey: ID!
  """The type of the issue"""
  issueType: ID!
  """The icon used to represent the type of issue"""
  issueIcon: String!
  """The key of the project, which is the prefix to the issueKey"""
  projectKey: ID!
  """The project fetched from jira"""
  project: JiraRemoteProject
  """The plaintext summary of the jira issue"""
  summary: String!
  """
  Field names that exists on the issue and can be used as estimation fields
  """
  possibleEstimationFields: [JiraIssueField!]!
  """Missing estimation field"""
  missingEstimationFieldHint: JiraIssueMissingEstimationFieldHintEnum
  """The stringified ADF of the jira issue description"""
  description: String!
  """The description converted into raw HTML"""
  descriptionHTML: String!
  """The last time this issue was updated"""
  lastUpdated: DateTime!
  """All the other fields associated with the issue"""
  extraFields: [JiraExtraField!]!
}

"""A connection to a list of items."""
type JiraIssueConnection {
  """Page info with cursors"""
  pageInfo: PageInfo
  """A list of edges."""
  edges: [JiraIssueEdge!]!
  """An error with the connection, if any"""
  error: StandardMutationError
}

"""An edge in a connection."""
type JiraIssueEdge {
  """The item at the end of the edge"""
  node: JiraIssue!
  """Cursor for pagination"""
  cursor: String
}

"""Possible voting field"""
type JiraIssueField {
  """ID of the field in Jira"""
  fieldId: ID!
  """Name of the field"""
  fieldName: String!
}

"""
A hint describing why a Jira issue is missing an estimation field and how to fix it
"""
enum JiraIssueMissingEstimationFieldHintEnum {
  """
  The story points field is missing on a team-managed project; add it in project settings
  """
  teamManagedStoryPoints
  """
  The story points field is missing on a company-managed project; add it to the board's estimation configuration
  """
  companyManagedStoryPoints
}

"""
The URLs for avatars. NOTE: If they are custom, an Authorization header is required!
"""
type JiraRemoteAvatarUrls {
  """48x48 pixel avatar URL"""
  x48: ID!
  """24x24 pixel avatar URL"""
  x24: ID!
  """16x16 pixel avatar URL"""
  x16: ID!
  """32x32 pixel avatar URL"""
  x32: ID!
}

"""A project fetched from Jira in real time"""
type JiraRemoteProject implements RepoIntegration {
  """Composite key: cloudId:projectKey"""
  id: ID!
  """Always jira for this type"""
  service: IntegrationProviderServiceEnum!
  """The parabol teamId this issue was fetched for"""
  teamId: ID!
  """The parabol userId this issue was fetched for"""
  userId: ID!
  """The REST API URL for this project resource"""
  self: ID!
  """
  The cloud ID that the project lives on. Does not exist on the Jira object!
  """
  cloudId: ID!
  """The project key prefix used in issue keys (e.g. "PROJ" in "PROJ-123")"""
  key: String!
  """The human-readable project name"""
  name: String!
  """URL of the project avatar image"""
  avatar: String
  avatarUrls: JiraRemoteAvatarUrls!
  projectCategory: JiraRemoteProjectCategory!
  """true if the project uses a simplified board configuration"""
  simplified: Boolean!
  """The project style: classic or next-gen"""
  style: String!
}

"""A project category fetched from a JiraRemoteProject"""
type JiraRemoteProjectCategory {
  self: String!
  id: String!
  name: String!
  description: String!
}

"""
A jira search query including all filters selected when the query was executed
"""
type JiraSearchQuery {
  """The unique ID of the search query"""
  id: ID!
  """The query string, either simple or JQL depending on the isJQL flag"""
  queryString: String!
  """true if the queryString is JQL, else false"""
  isJQL: Boolean!
  """The list of project keys selected as a filter. null if not set"""
  projectKeyFilters: [ID!]!
  """the time the search query was last used. Used for sorting"""
  lastUsedAt: DateTime!
}

"""
Input for saving or removing a Jira search query with optional project key filters
"""
input JiraSearchQueryInput {
  """The query string, either simple or JQL depending on the isJQL flag"""
  queryString: String!
  """true if the queryString is JQL, else false"""
  isJQL: Boolean!
  """The list of project keys selected as a filter. null if not set"""
  projectKeyFilters: [ID!]
  """true if this query should be deleted"""
  isRemove: Boolean
}

"""Jira Data Center integration data for a given team member"""
type JiraServerIntegration {
  """Composite key in jiraServer:providerId format"""
  id: ID
  """The OAuth1 Authorization for this team member"""
  auth: TeamMemberIntegrationAuthOAuth1
  """The non-global providers shared with the team or organization"""
  sharedProviders: [IntegrationProviderOAuth1!]!
  """
  A list of issues coming straight from the jira integration for a specific team member
  """
  issues(
    first: Int = 25
    after: String = "-1"
    """A string of text to search for, or JQL if isJQL is true"""
    queryString: String
    """true if the queryString is JQL, else false"""
    isJQL: Boolean!
    projectKeyFilters: [ID!]
  ): JiraServerIssueConnection!
  """
  A list of projects accessible by this team member. empty if viewer is not the user
  """
  projects: [JiraServerRemoteProject!]!
  providerId: ID
  """
  the list of suggested search queries, sorted by most recent. Guaranteed to be < 60 days old
  """
  searchQueries: [JiraSearchQuery!]!
}

"""The Jira Issue that comes direct from Jira Data Center"""
type JiraServerIssue implements TaskIntegration {
  """GUID providerId:repositoryId:issueId"""
  id: ID!
  """The issue key as shown in Jira (e.g. "PROJ-123")"""
  issueKey: ID!
  """The issue type identifier"""
  issueType: ID!
  """The ID of the Jira project this issue belongs to"""
  projectId: ID!
  """The key of the Jira project (e.g. "PROJ")"""
  projectKey: ID!
  """The human-readable project name"""
  projectName: String!
  """The parabol teamId this issue was fetched for"""
  teamId: ID!
  """The parabol userId this issue was fetched for"""
  userId: ID!
  """The url to access the issue"""
  url: String!
  """The plaintext summary of the jira issue"""
  summary: String!
  """The stringified ADF description of the Jira issue"""
  description: String!
  """The description converted into raw HTML"""
  descriptionHTML: String!
  """
  Names of fields on this issue that can be used for story point estimation
  """
  possibleEstimationFieldNames: [String!]!
  """The timestamp the issue was last updated"""
  updatedAt: DateTime!
}

"""A connection to a list of items."""
type JiraServerIssueConnection {
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """A list of edges."""
  edges: [JiraServerIssueEdge!]!
  """An error with the connection, if any"""
  error: StandardMutationError
}

"""An edge in a connection."""
type JiraServerIssueEdge {
  """The item at the end of the edge"""
  node: JiraServerIssue!
  """Cursor for pagination"""
  cursor: String
}

"""A project fetched from Jira Data Center in real time"""
type JiraServerRemoteProject implements RepoIntegration {
  """Composite key: providerId:projectKey"""
  id: ID!
  """Always jiraServer for this type"""
  service: IntegrationProviderServiceEnum!
  """The parabol teamId this issue was fetched for"""
  teamId: ID!
  """The parabol userId this issue was fetched for"""
  userId: ID!
  """The human-readable project name"""
  name: String!
  """URL of the project avatar image"""
  avatar: String!
  avatarUrls: JiraRemoteAvatarUrls!
  projectCategory: JiraRemoteProjectCategory!
}

"""
Input for a Jira Data Center search query with optional project key filters
"""
input JiraServerSearchQueryInput {
  """The query string, either simple text or JQL depending on isJQL"""
  queryString: String!
  """true if the queryString is JQL, else false"""
  isJQL: Boolean!
  """The list of project keys to filter results by"""
  projectKeyFilters: [ID!]!
}

"""Return object for JoinMeetingPayload"""
union JoinMeetingPayload = ErrorPayload | JoinMeetingSuccess

"""The result of a user successfully joining a meeting in progress"""
type JoinMeetingSuccess {
  """The ID of the meeting that was joined"""
  meetingId: ID!
  """The meeting with the updated stages, if any"""
  meeting: NewMeeting!
}

"""Return value for joinTeam, which could be an error"""
union JoinTeamPayload = ErrorPayload | JoinTeamSuccess

"""The result of a user successfully joining a team"""
type JoinTeamSuccess {
  """The viewer who just joined the team"""
  viewer: User!
  """The team that was joined"""
  team: Team!
  """The newly created team member"""
  teamMember: TeamMember!
}

"""Represents the Linear integration details for a team member."""
type LinearIntegration {
  """The team member's authentication details for this integration"""
  auth: TeamMemberIntegrationAuthOAuth2
  """
  The cloud provider the team member may choose to integrate with. Nullable based on env vars
  """
  cloudProvider: IntegrationProviderOAuth2
  """Composite key in linear:teamId:userId format"""
  id: ID!
  """An historical list of Linear Sprint Poker search queries"""
  linearSearchQueries: [LinearSearchQuery!]!
}

"""A connection to a list of items."""
type LinearIntegrationConnection {
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """A list of edges."""
  edges: [LinearIntegrationEdge!]!
  """An error with the connection, if any"""
  error: StandardMutationError
}

"""An edge in a connection."""
type LinearIntegrationEdge {
  """The item at the end of the edge"""
  node: TaskIntegration!
  """Cursor for pagination"""
  cursor: String
}

"""
A Linear search query including the search query and the project filters
"""
type LinearSearchQuery {
  """shortid"""
  id: ID!
  """The query string used to search Linear issue titles and descriptions"""
  queryString: String!
  """
  The list of ids of teams or projects that have been selected as a filter.
  Elements are of the form _xLinearTeam:[id] or _xLinearProject:[id].
  Null if none have been selected
  """
  selectedProjectsIds: [ID!]
  """the time the search query was last used. Used for sorting"""
  lastUsedAt: DateTime!
}

"""Return object for linkMattermostChannel"""
union LinkMattermostChannelPayload = ErrorPayload | LinkMattermostChannelSuccess

"""The result of linking a Mattermost channel to a team for notifications"""
type LinkMattermostChannelSuccess {
  """The ID of the team the channel was linked to"""
  teamId: ID!
  """The IDs of all currently linked Mattermost channels for this team"""
  linkedChannels: [ID!]!
  """The notification settings that were added"""
  teamNotificationSettings: TeamNotificationSettings!
}

"""Integration Auth and shared providers available to the team member"""
type MSTeamsIntegration {
  """The OAuth2 Authorization for this team member"""
  auth: TeamMemberIntegrationAuthWebhook
  """The non-global providers shared with the team or organization"""
  sharedProviders: [IntegrationProviderWebhook!]!
  """
  An active team member has integrated with a provider for this integration
  """
  isActive: Boolean!
  """
  If any team member integrated with mattermost, this will be the active provider for this team
  """
  activeProvider: IntegrationProviderWebhook
  """Team notification settings for this provider."""
  teamNotificationSettings(channel: ID): TeamNotificationSettings
}

"""An invitation and expiration"""
type MassInvitation {
  """the invitation token"""
  id: ID!
  """the expiration for the token"""
  expiration: DateTime!
  """
  The meeting ID to auto-join upon accepting, if the invitation is tied to a specific meeting
  """
  meetingId: ID
}

"""
The result of validating a mass invitation token, including team info or an error reason
"""
type MassInvitationPayload {
  """The reason the invitation is invalid, null if valid"""
  errorType: TeamInvitationErrorEnum
  """
  The name of the person that sent the invitation, present if errorType is expired
  """
  inviterName: String
  """The teamId from the token"""
  teamId: ID
  """name of the inviting team, present if invitation exists"""
  teamName: String
}

"""Integration Auth and shared providers available to the team member"""
type MattermostIntegration {
  """The OAuth2 Authorization for this team member"""
  auth: TeamMemberIntegrationAuthWebhook
  """The non-global providers shared with the team or organization"""
  sharedProviders: [IntegrationProviderWebhook!]!
  """
  An active team member has integrated with a provider for this integration
  """
  isActive: Boolean!
  """
  If any team member integrated with mattermost, this will be the active provider for this team
  """
  activeProvider: IntegrationProviderWebhook
  """Team notification settings for this provider."""
  teamNotificationSettings(channel: ID): TeamNotificationSettings
  """All linked channels for the global Mattermost integration"""
  linkedChannels: [ID!]!
}

"""A connection to list of meetings"""
type MeetingConnection {
  """Page info with cursors as strings"""
  pageInfo: PageInfoDateCursor!
  """A list of edges."""
  edges: [MeetingEdge!]!
}

"""An edge in a connection."""
type MeetingEdge {
  """The item at the end of the edge"""
  node: NewMeeting!
  cursor: DateTime!
}

"""
A greeting shown at the start of a check-in meeting, displayed in a foreign language
"""
type MeetingGreeting {
  """The foreign-language greeting"""
  content: String!
  """The source language for the greeting"""
  language: String!
}

"""All the user details for a specific meeting"""
interface MeetingMember {
  """A composite of userId::meetingId"""
  id: ID!
  """true if present, false if absent, else null"""
  isCheckedIn: Boolean @deprecated(reason: "Members are checked in when they enter the meeting now & not created beforehand")
  """The meeting this member participated in"""
  meetingId: ID!
  """The type of meeting"""
  meetingType: MeetingTypeEnum!
  """The team the meeting belongs to"""
  teamId: ID!
  """The team member record for this user"""
  teamMember: TeamMember!
  """The user who participated in the meeting"""
  user: User!
  """The ID of the user who participated in the meeting"""
  userId: ID!
  """The last time a meeting was updated (stage completed, finished, etc)"""
  updatedAt: DateTime!
}

"""A meeting series representing a set of recurring meetings"""
type MeetingSeries {
  """The unique meeting series ID"""
  id: ID!
  """The team that owns the meeting series"""
  teamId: ID!
  """The type of the recurring meeting"""
  meetingType: MeetingTypeEnum!
  """
  The name of the meeting series used to generate the names of the recurring meetings
  """
  title: String!
  """
  The RFC-2445 recurrence rule that determines when meetings should start
  """
  recurrenceRule: String!
  """The duration, in minutes, of meetings that recur"""
  duration: Int!
  """When the meeting series was created"""
  createdAt: DateTime!
  """When the meeting series was last updated"""
  updatedAt: DateTime!
  """When the meeting series was cancelled"""
  cancelledAt: DateTime
  """The meetings that belong to the meeting series"""
  activeMeetings: [NewMeeting!]!
  """
  The most recent meeting in the series. Any active meeting takes precendence over inactive
  meetings. Null when the series has been scheduled for the future and no meeting has
  spawned from the recurrence cron yet.
  """
  mostRecentMeeting: NewMeeting
  """
  The next scheduled occurrence of the recurrence rule, computed server-side from
  recurrenceRule. Null if the series is cancelled or has no future occurrences.
  """
  nextMeetingDate: DateTime
  """
  URL-safe slug identifying the series in invitee-facing links (e.g., gcal descriptions).
  Format: <kebab-title>-<cipher>, mirroring the Pages convention. The trailing cipher hides
  the DB id; the leading title slug is decorative. Use with the /meeting-series/:slug route,
  which redirects an invitee into any active meeting for the series or back to /meetings.
  """
  urlSlug: String!
}

type MeetingStageTimeLimitPayload {
  """The new notification that was just created"""
  notification: NotificationMeetingStageTimeLimitEnd!
}

"""
Basic metadata about a meeting, used for aggregated org-level statistics
"""
type MeetingStat {
  """The unique meeting ID"""
  id: ID!
  """The type of meeting (action, retrospective, poker, teamPrompt)"""
  meetingType: MeetingTypeEnum!
  """When the meeting was created"""
  createdAt: DateTime!
}

"""
A discriminated union of all possible meeting subscription event payloads
"""
type MeetingSubscriptionPayload {
  fieldName: String!
  AddTranscriptionBotSuccess: AddTranscriptionBotSuccess
  AutogroupSuccess: AutogroupSuccess
  AddCommentSuccess: AddCommentSuccess
  CreatePollSuccess: CreatePollSuccess
  AddReactjiToReactableSuccess: AddReactjiToReactableSuccess
  CreateReflectionPayload: CreateReflectionPayload
  DeleteCommentSuccess: DeleteCommentSuccess
  DragDiscussionTopicPayload: DragDiscussionTopicPayload
  DragEstimatingTaskSuccess: DragEstimatingTaskSuccess
  EditCommentingSuccess: EditCommentingSuccess
  EditReflectionPayload: EditReflectionPayload
  EndDraggingReflectionPayload: EndDraggingReflectionPayload
  EndRetrospectiveSuccess: EndRetrospectiveSuccess
  EndTeamPromptSuccess: EndTeamPromptSuccess
  FlagReadyToAdvanceSuccess: FlagReadyToAdvanceSuccess
  GenerateGroupsSuccess: GenerateGroupsSuccess
  NewMeetingCheckInPayload: NewMeetingCheckInPayload
  PromoteNewMeetingFacilitatorPayload: PromoteNewMeetingFacilitatorPayload
  RemoveReflectionPayload: RemoveReflectionPayload
  ResetReflectionGroupsSuccess: ResetReflectionGroupsSuccess
  ResetRetroMeetingToGroupStagePayload: ResetRetroMeetingToGroupStagePayload
  UngroupReflectionSuccess: UngroupReflectionSuccess
  RevealTeamHealthVotesSuccess: RevealTeamHealthVotesSuccess
  SetMeetingMusicSuccess: SetMeetingMusicSuccess
  SetPhaseFocusPayload: SetPhaseFocusPayload
  SetStageTimerPayload: SetStageTimerPayload
  SetTaskHighlightSuccess: SetTaskHighlightSuccess
  SetTeamHealthVoteSuccess: SetTeamHealthVoteSuccess
  StartDraggingReflectionPayload: StartDraggingReflectionPayload
  UpdateCommentContentSuccess: UpdateCommentContentSuccess
  UpdateDragLocationPayload: UpdateDragLocationPayload
  UpdateMeetingPromptSuccess: UpdateMeetingPromptSuccess
  UpdateNewCheckInQuestionPayload: UpdateNewCheckInQuestionPayload
  UpdatedNotification: UpdatedNotification
  UpdateReflectionContentPayload: UpdateReflectionContentPayload
  UpdateReflectionGroupTitlePayload: UpdateReflectionGroupTitlePayload
  UpdateRetroMaxVotesSuccess: UpdateRetroMaxVotesSuccess
  UpdatePokerScopeSuccess: UpdatePokerScopeSuccess
  VoteForReflectionGroupPayload: VoteForReflectionGroupPayload
  VoteForPokerStorySuccess: VoteForPokerStorySuccess
  PokerRevealVotesSuccess: PokerRevealVotesSuccess
  PokerResetDimensionSuccess: PokerResetDimensionSuccess
  PokerAnnounceDeckHoverSuccess: PokerAnnounceDeckHoverSuccess
  JoinMeetingSuccess: JoinMeetingSuccess
  SetPokerSpectateSuccess: SetPokerSpectateSuccess
  SetTaskEstimateSuccess: SetTaskEstimateSuccess
  UpsertTeamPromptResponseSuccess: UpsertTeamPromptResponseSuccess
  UpdateMeetingTemplateSuccess: UpdateMeetingTemplateSuccess
  ReflectionEmbeddingSuccess: ReflectionEmbeddingSuccess
}

"""
A meeting template that can be shared across a team, organization, or publicly
"""
interface MeetingTemplate {
  """The unique template ID"""
  id: ID!
  """When the template was created"""
  createdAt: DateTime!
  """True if template can be used, else false"""
  isActive: Boolean!
  """
  True if template is available to all teams including non-paying teams, else false
  """
  isFree: Boolean!
  """The time of the meeting the template was last used"""
  lastUsedAt: DateTime
  """The name of the template"""
  name: String!
  """The organization that owns the team that created the template"""
  orgId: ID!
  """Who can see this template"""
  scope: SharingScopeEnum!
  """The team this template belongs to"""
  teamId: ID!
  """The team this template belongs to"""
  team: Team! @scope(name: TEAMS_READ)
  """The type of the template"""
  type: MeetingTypeEnum!
  updatedAt: DateTime!
  """
  The category this template falls under, e.g. retro, feedback, strategy, etc.
  """
  category: String!
  """
  Whether this template should be in the recommended/quick start sections in the UI.
  """
  isRecommended: Boolean!
  """The url to the illustration used by the template"""
  illustrationUrl: String!
  """The lowest scope of the permissions available to the viewer"""
  viewerLowestScope: SharingScopeEnum!
}

"""A connection to a list of items."""
type MeetingTemplateConnection {
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """A list of edges."""
  edges: [MeetingTemplateEdge!]!
}

"""An edge in a connection."""
type MeetingTemplateEdge {
  """The item at the end of the edge"""
  node: MeetingTemplate!
  """A cursor for use in pagination"""
  cursor: String!
}

"""The type of meeting"""
enum MeetingTypeEnum {
  """Check-in meeting where each team member gives a brief status update"""
  action
  """
  Retrospective meeting for reflecting on what went well, what didn't, and what to change
  """
  retrospective
  """Sprint Poker meeting for estimating task complexity via planning poker"""
  poker
  """
  Standup meeting where each team member shares async written responses to a prompt
  """
  teamPrompt
}

"""Return value for modifyCheckInQuestion, which could be an error"""
union ModifyCheckInQuestionPayload = ErrorPayload | ModifyCheckInQuestionSuccess

"""The result of modifying the check-in question for a meeting"""
type ModifyCheckInQuestionSuccess {
  """The updated check-in question text, null if unchanged"""
  modifiedCheckInQuestion: String
}

"""The tone to apply when modifying AI-generated content"""
enum ModifyType {
  """Make the content more serious and professional"""
  SERIOUS
  """Make the content more humorous and lighthearted"""
  FUNNY
  """Make the content more energetic and enthusiastic"""
  EXCITING
}

"""The result of reordering a dimension within a Poker template"""
type MovePokerTemplateDimensionPayload {
  """Error information if the mutation failed"""
  error: StandardMutationError
  """The reordered dimension"""
  dimension: TemplateDimension
}

"""Return object for MovePokerTemplateScaleValuePayload"""
union MovePokerTemplateScaleValuePayload = ErrorPayload | MovePokerTemplateScaleValueSuccess

type MovePokerTemplateScaleValueSuccess {
  """The scale after values are moved"""
  scale: TemplateScale!
}

"""The result of reordering a prompt within a Retrospective template"""
type MoveReflectTemplatePromptPayload {
  """Error information if the mutation failed"""
  error: StandardMutationError
  """The reordered prompt"""
  prompt: ReflectPrompt
}

type Mutation {
  """Create a new agenda item"""
  addAgendaItem(
    """The new task including an id, teamMemberId, and content"""
    newAgendaItem: CreateAgendaItemInput!
  ): AddAgendaItemPayload @scope(name: TEAMS_WRITE)
  """Connect the current user's Atlassian (Jira Cloud) account to a team"""
  addAtlassianAuth(code: ID!, teamId: ID!): AddAtlassianAuthPayload! @scope(name: TEAMS_WRITE)
  """Add a comment to a discussion"""
  addComment(
    """A partial new comment"""
    comment: AddCommentInput!
  ): AddCommentPayload! @scope(name: COMMENTS_WRITE)
  """Add a new dimension for the poker template"""
  addPokerTemplateDimension(templateId: ID!): AddPokerTemplateDimensionPayload! @scope(name: TEMPLATES_WRITE)
  """Add a new scale for the poker template"""
  addPokerTemplateScale(parentScaleId: ID, teamId: ID!): AddPokerTemplateScalePayload! @scope(name: TEMPLATES_WRITE)
  """Add a new scale value for a scale in a poker template"""
  addPokerTemplateScaleValue(scaleId: ID!, scaleValue: AddTemplateScaleInput!): AddPokerTemplateScaleValuePayload! @scope(name: TEMPLATES_WRITE)
  """Add a new prompt to an existing reflect template"""
  addReflectTemplatePrompt(templateId: ID!): AddReflectTemplatePromptPayload! @scope(name: TEMPLATES_WRITE)
  """Connect the current user's Slack account to a team"""
  addSlackAuth(code: ID!, teamId: ID!): AddSlackAuthPayload! @scope(name: TEAMS_WRITE)
  """Connect the current user's GitHub account to a team"""
  addGitHubAuth(code: ID!, teamId: ID!): AddGitHubAuthPayload! @scope(name: TEAMS_WRITE)
  """
  Create a new organization with an initial team, optionally inviting members by email
  """
  addOrg(
    """The new team object with exactly 1 team member"""
    newTeam: NewTeamInput!
    """The name of the new team"""
    orgName: String!
    invitees: [Email!]
  ): AddOrgPayload! @scope(name: ORGS_WRITE)
  """Create a new team and add the first team member"""
  addTeam(
    """The new team object"""
    newTeam: NewTeamInput!
    invitees: [Email!]
  ): AddTeamPayload! @scope(name: TEAMS_WRITE)
  """Archive an organization, making it inactive"""
  archiveOrganization(
    """The orgId to archive"""
    orgId: ID!
  ): ArchiveOrganizationPayload! @scope(name: ORGS_WRITE)
  """
  Archive a team. If the team has never been used, it will be permanently deleted.
  """
  archiveTeam(
    """The teamId to archive (or delete, if team is unused)"""
    teamId: ID!
  ): ArchiveTeamPayload! @scope(name: TEAMS_WRITE)
  """Archive a timeline event"""
  archiveTimelineEvent(
    """the id for the timeline event"""
    timelineEventId: ID!
  ): ArchiveTimelineEventPayload! @scope(name: MEETINGS_WRITE)
  """
  Change the team a task is associated with. Also copy the viewers integration if necessary.
  """
  changeTaskTeam(
    """The task to change"""
    taskId: ID!
    """The new team to assign the task to"""
    teamId: ID!
  ): ChangeTaskTeamPayload @scope(name: TASKS_WRITE)
  """set the interaction status of a notifcation"""
  setNotificationStatus(
    """The id of the notification"""
    notificationId: ID!
    status: NotificationStatusEnum!
  ): SetNotificationStatusPayload @scope(name: USERS_WRITE)
  """
  Create a new top-level page. To create a child page, insert a page block link inside an existing document.
  """
  createPage(
    """
    The team to scope this page under. If omitted, the page is created as a personal page.
    """
    teamId: ID
  ): CreatePagePayload! @scope(name: PAGES_WRITE)
  """Create a personal access token for API access"""
  createPersonalAccessToken(
    """A human-readable label for the token"""
    name: String!
    """The scopes this token is permitted to use"""
    scopes: [OAuthScopeEnum!]!
    """
    Restrict token to specific orgs; null means all orgs the user belongs to
    """
    grantedOrgIds: [ID!]
    """
    Restrict token to specific teams; null means all teams the user belongs to
    """
    grantedTeamIds: [ID!]
    """
    Restrict token to specific pages; null means all pages the user can access
    """
    grantedPageIds: [ID!]
    """Expiration date; cannot be more than 1 year in the future"""
    expiresAt: DateTime!
  ): CreatePersonalAccessTokenSuccess! @scope(name: USERS_WRITE)
  """
  Push a Parabol task to an external integration as a new issue (e.g. Jira, GitHub)
  """
  createTaskIntegration(
    """Which integration to push the task to"""
    integrationProviderService: IntegrationProviderServiceEnum!
    """Jira projectId, GitHub nameWithOwner etc."""
    integrationRepoId: ID!
    """The id of the task to convert to an issue"""
    taskId: ID!
  ): CreateTaskIntegrationPayload @scope(name: TASKS_WRITE)
  """
  Generate a new OAuth1 request token and encode it in the authorization URL to start an oauth1 flow
  """
  createOAuth1AuthorizeUrl(
    """Id of the integration provider with OAuth1 auth strategy"""
    providerId: ID!
    """Id of the team where the integration should be added"""
    teamId: ID!
  ): CreateOAuth1AuthorizationURLPayload @scope(name: TEAMS_WRITE)
  """Create a new OAuth 2.0 Application"""
  createOAuthAPIProvider(orgId: ID!, name: String!, redirectUris: [RedirectURI!]!, scopes: [OAuthScopeEnum!]!): CreateOAuthAPIProviderPayload! @scope(name: ORGS_WRITE)
  """Update an OAuth 2.0 Application"""
  updateOAuthAPIProvider(providerId: ID!, name: String, redirectUris: [RedirectURI!], scopes: [OAuthScopeEnum!]): UpdateOAuthAPIProviderPayload! @scope(name: ORGS_WRITE)
  """Delete an OAuth 2.0 Application"""
  deleteOAuthAPIProvider(providerId: ID!): DeleteOAuthAPIProviderPayload! @scope(name: ORGS_WRITE)
  """Regenerate the OAuth 2.0 client secret for an application"""
  regenerateOAuthAPIProviderSecret(providerId: ID!): RegenerateOAuthAPIProviderSecretPayload! @scope(name: ORGS_WRITE)
  """Update SCIM settings for the organization"""
  updateSCIM(
    """The organization's ID to update SCIM for"""
    orgId: ID!
    """The authentication type. SCIM will be disabled if set to null"""
    authenticationType: SCIMAuthenticationTypeEnum
  ): UpdateSCIMPayload! @scope(name: ORGS_WRITE)
  """Create a new reflection"""
  createReflection(input: CreateReflectionInput!): CreateReflectionPayload @scope(name: MEETINGS_WRITE)
  """Create a new task, triggering a CreateCard for other viewers"""
  createTask(
    """The new task including an id, status, and type, and teamMemberId"""
    newTask: CreateTaskInput!
    """The part of the site where the creation occurred"""
    area: AreaEnum
  ): CreateTaskPayload! @scope(name: TASKS_WRITE)
  """Delete a comment from a discussion"""
  deleteComment(commentId: ID!, meetingId: ID!): DeleteCommentPayload! @scope(name: COMMENTS_WRITE)
  """Delete (not archive!) a task"""
  deleteTask(
    """The taskId to delete"""
    taskId: ID!
  ): DeleteTaskPayload @scope(name: TASKS_WRITE)
  """Delete a user, removing them from all teams and orgs"""
  deleteUser(
    """a userId"""
    userId: ID
    """the user email"""
    email: ID
    """the reason why the user wants to delete their account"""
    reason: String
  ): DeleteUserPayload! @scope(name: USERS_WRITE)
  """Deny a user from joining via push invitation"""
  denyPushInvitation(teamId: ID!, userId: ID!): DenyPushInvitationPayload @scope(name: TEAMS_WRITE)
  """Dismiss the new feature announcement for the current user"""
  dismissNewFeature: DismissNewFeaturePayload! @scope(name: USERS_WRITE)
  """Dismiss a suggested action"""
  dismissSuggestedAction(
    """The id of the suggested action to dismiss"""
    suggestedActionId: ID!
  ): DismissSuggestedActionPayload! @scope(name: USERS_WRITE)
  """Downgrade a paid account to the starter plan service"""
  downgradeToStarter(
    """the org requesting the upgrade"""
    orgId: ID!
    """the reasons the user is leaving"""
    reasonsForLeaving: [ReasonToDowngradeEnum!]
    """
    the name of the tool they are moving to. only required if anotherTool is selected as a reason to downgrade
    """
    otherTool: String
  ): DowngradeToStarterPayload @scope(name: ORGS_WRITE)
  """Changes the priority of the discussion topics"""
  dragDiscussionTopic(meetingId: ID!, stageId: ID!, sortOrder: Float!): DragDiscussionTopicPayload @scope(name: MEETINGS_WRITE)
  """Changes the ordering of the estimating tasks"""
  dragEstimatingTask(
    meetingId: ID!
    taskId: ID!
    """
    The index of the tasks will be moved to, in the list of estimating tasks sidebar section
    """
    newPositionIndex: Int!
  ): DragEstimatingTaskPayload! @scope(name: MEETINGS_WRITE)
  """Send an email to reset a password"""
  emailPasswordReset(
    """email to send the password reset code to"""
    email: ID!
  ): EmailPasswordResetPayload! @scope(name: USERS_WRITE)
  """
  Broadcast that the current user started or stopped typing a comment in a discussion
  """
  editCommenting(
    """True if the user started commenting, false if they stopped"""
    isCommenting: Boolean!
    discussionId: ID!
  ): EditCommentingPayload @scope(name: MEETINGS_WRITE)
  """
  Replace the content of a page. Warning: this deletes the content history.
  """
  editPageContent(
    """The ID of the page to edit"""
    pageId: ID!
    """The new content of the page, in the format specified by format"""
    content: String!
    """The format of the content string: markdown or tiptap JSON"""
    format: PageContentFormatEnum!
  ): EditPageContentSuccess! @scope(name: PAGES_WRITE)
  """Finish a sprint poker meeting"""
  endSprintPoker(
    """The meeting to end"""
    meetingId: ID!
  ): EndSprintPokerPayload! @scope(name: MEETINGS_WRITE)
  """
  Broadcast that the current user started or stopped editing a reflection
  """
  editReflection(
    """True if the user started editing, false if they stopped"""
    isEditing: Boolean!
    meetingId: ID!
    promptId: ID!
  ): EditReflectionPayload @scope(name: MEETINGS_WRITE)
  """Announce to everyone that you are editing a task"""
  editTask(
    """The task id that is being edited"""
    taskId: ID!
    """true if the editing is starting, false if it is stopping"""
    isEditing: Boolean!
  ): EditTaskPayload @scope(name: TASKS_WRITE)
  """Finish a check-in meeting"""
  endCheckIn(
    """The meeting to end"""
    meetingId: ID!
  ): EndCheckInPayload! @scope(name: MEETINGS_WRITE)
  """Broadcast that the viewer stopped dragging a reflection"""
  endDraggingReflection(
    reflectionId: ID!
    """
    if it was a drop (isDragging = false), the type of item it was dropped on. null if there was no valid drop target
    """
    dropTargetType: DragReflectionDropTargetTypeEnum
    """
    if dropTargetType could refer to more than 1 component, this ID defines which one
    """
    dropTargetId: ID
    """the ID of the drag to connect to the start drag event"""
    dragId: ID
  ): EndDraggingReflectionPayload @scope(name: MEETINGS_WRITE)
  """Finish a retrospective meeting"""
  endRetrospective(
    """The meeting to end"""
    meetingId: ID!
  ): EndRetrospectivePayload! @scope(name: MEETINGS_WRITE)
  """
  Flag the current user as ready (or not ready) to advance to the next stage of a meeting
  """
  flagReadyToAdvance(
    meetingId: ID!
    """the stage that the viewer marked as ready"""
    stageId: ID!
    """true if ready to advance, else false"""
    isReady: Boolean!
  ): FlagReadyToAdvancePayload! @scope(name: MEETINGS_WRITE)
  """Invalidate all sessions by blacklisting all JWTs issued before now"""
  invalidateSessions: InvalidateSessionsPayload! @scope(name: USERS_WRITE)
  """Send a team invitation to an email address"""
  inviteToTeam(
    """the specific meeting where the invite occurred, if any"""
    meetingId: ID
    """The id of the inviting team"""
    teamId: ID!
    invitees: [Email!]!
  ): InviteToTeamPayload! @scope(name: TEAMS_WRITE)
  """
  Generate AI inspiration items from a user's recent work in a Your Work integration
  """
  generateInspirationItems(input: GenerateInspirationItemsInput!): GenerateInspirationItemsSuccess! @scope(name: MEETINGS_WRITE)
  """Reorder a dimension within a poker template"""
  movePokerTemplateDimension(dimensionId: ID!, sortOrder: String!): MovePokerTemplateDimensionPayload! @scope(name: TEMPLATES_WRITE)
  """Reorder a prompt within a reflect template"""
  moveReflectTemplatePrompt(promptId: ID!, sortOrder: String!): MoveReflectTemplatePromptPayload @scope(name: TEMPLATES_WRITE)
  """
  Move one or more teams to a different org. Requires billing leader rights on both orgs.
  """
  moveTeamToOrg(
    """The teamId that you want to move"""
    teamIds: [ID!]!
    """The ID of the organization you want to move the team to"""
    orgId: ID!
  ): String @scope(name: ORGS_WRITE)
  """
  Advance the meeting by marking a stage complete and/or moving the facilitator to a different stage
  """
  navigateMeeting(
    """The stage that the facilitator would like to mark as complete"""
    completedStageId: ID
    """The stage where the facilitator is"""
    facilitatorStageId: ID
    """The meeting ID"""
    meetingId: ID!
  ): NavigateMeetingPayload! @scope(name: MEETINGS_WRITE)
  """Save or remove a Jira search query for a team's sprint poker backlog"""
  persistJiraSearchQuery(
    """the team with the settings we add the query to"""
    teamId: ID!
    """the jira search query to persist (or remove, if isRemove is true)"""
    input: JiraSearchQueryInput!
  ): PersistJiraSearchQueryPayload! @scope(name: TEAMS_WRITE)
  """Request to be invited to a team in real time"""
  pushInvitation(
    """the meeting ID the pusher would like to join"""
    meetingId: ID
    teamId: ID!
  ): PushInvitationPayload @scope(name: TEAMS_WRITE)
  """Change a facilitator while the meeting is in progress"""
  promoteNewMeetingFacilitator(
    """userId of the new facilitator for this meeting"""
    facilitatorUserId: ID!
    meetingId: ID!
  ): PromoteNewMeetingFacilitatorPayload @scope(name: MEETINGS_WRITE)
  """Promote another team member to be the leader"""
  promoteToTeamLead(
    """Team id of the team which is about to get a new team leader"""
    teamId: ID!
    """userId who will be set as a new team leader"""
    userId: ID!
  ): PromoteToTeamLeadPayload @scope(name: TEAMS_WRITE)
  """Update the description of a reflection prompt"""
  reflectTemplatePromptUpdateDescription(promptId: ID!, description: String!): ReflectTemplatePromptUpdateDescriptionPayload @scope(name: TEMPLATES_WRITE)
  """Update the description of a poker template dimension"""
  pokerTemplateDimensionUpdateDescription(dimensionId: ID!, description: String!): PokerTemplateDimensionUpdateDescriptionPayload @scope(name: TEMPLATES_WRITE)
  """Update the color of a reflect template prompt"""
  reflectTemplatePromptUpdateGroupColor(promptId: ID!, groupColor: String!): ReflectTemplatePromptUpdateGroupColorPayload @scope(name: TEMPLATES_WRITE)
  """Remove an agenda item"""
  removeAgendaItem(
    """The agenda item unique id"""
    agendaItemId: ID!
  ): RemoveAgendaItemPayload @scope(name: TEAMS_WRITE)
  """Disconnect a team member from atlassian"""
  removeAtlassianAuth(
    """the teamId to disconnect from the token"""
    teamId: ID!
  ): RemoveAtlassianAuthPayload! @scope(name: TEAMS_WRITE)
  """Disconnect a team member from GitHub"""
  removeGitHubAuth(
    """the teamId to disconnect from the token"""
    teamId: ID!
  ): RemoveGitHubAuthPayload! @scope(name: TEAMS_WRITE)
  """Remove multiple users from an org"""
  removeOrgUsers(
    """The list of user IDs to remove"""
    userIds: [ID!]!
    """The org that does not want them anymore"""
    orgId: ID!
  ): RemoveOrgUsersPayload! @scope(name: ORGS_WRITE)
  """Remove a poker meeting template"""
  removePokerTemplate(templateId: ID!): RemovePokerTemplatePayload! @scope(name: TEMPLATES_WRITE)
  """Remove a template full of prompts"""
  removeReflectTemplate(templateId: ID!): RemoveReflectTemplatePayload @scope(name: TEMPLATES_WRITE)
  """Remove a prompt from a template"""
  removeReflectTemplatePrompt(promptId: ID!): RemoveReflectTemplatePromptPayload @scope(name: TEMPLATES_WRITE)
  """Remove a dimension from a template"""
  removePokerTemplateDimension(dimensionId: ID!): RemovePokerTemplateDimensionPayload! @scope(name: TEMPLATES_WRITE)
  """Rename a meeting"""
  renameMeeting(
    """the new meeting name"""
    name: String!
    """the meeting with the new name"""
    meetingId: ID!
  ): RenameMeetingPayload! @scope(name: MEETINGS_WRITE)
  """Rename a meeting template"""
  renameMeetingTemplate(templateId: ID!, name: String!): RenameMeetingTemplatePayload @scope(name: TEMPLATES_WRITE)
  """Rename a reflect template prompt"""
  renameReflectTemplatePrompt(promptId: ID!, question: String!): RenameReflectTemplatePromptPayload @scope(name: TEMPLATES_WRITE)
  """Rename a poker template dimension"""
  renamePokerTemplateDimension(dimensionId: ID!, name: String!): RenamePokerTemplateDimensionPayload! @scope(name: TEMPLATES_WRITE)
  """Rename a poker template scale"""
  renamePokerTemplateScale(scaleId: ID!, name: String!): RenamePokerTemplateScalePayload! @scope(name: TEMPLATES_WRITE)
  """Remove a scale from a template"""
  removePokerTemplateScale(scaleId: ID!): RemovePokerTemplateScalePayload! @scope(name: TEMPLATES_WRITE)
  """Remove a scale value from the scale of a template"""
  removePokerTemplateScaleValue(scaleId: ID!, label: String!): RemovePokerTemplateScaleValuePayload! @scope(name: TEMPLATES_WRITE)
  """Remove a reflection"""
  removeReflection(reflectionId: ID!): RemoveReflectionPayload @scope(name: MEETINGS_WRITE)
  """Disconnect a team member from Slack"""
  removeSlackAuth(
    """the teamId to disconnect from the token"""
    teamId: ID!
  ): RemoveSlackAuthPayload! @scope(name: TEAMS_WRITE)
  """Remove a team member from the team"""
  removeTeamMember(
    """The teamId of the team the user is being removed from"""
    teamId: ID!
    """The userId of the person who is being removed"""
    userId: ID!
  ): RemoveTeamMemberPayload @scope(name: TEAMS_WRITE)
  """Reset the password for an account"""
  resetPassword(
    """the password reset token"""
    token: ID!
    """The new password for the account"""
    newPassword: String!
  ): ResetPasswordPayload! @scope(name: USERS_WRITE)
  """Reset a retro meeting to group stage"""
  resetRetroMeetingToGroupStage(meetingId: ID!): ResetRetroMeetingToGroupStagePayload! @scope(name: MEETINGS_WRITE)
  """Update a personal access token's fields or revoke it"""
  updatePersonalAccessToken(
    """The ID of the token to update"""
    tokenId: ID!
    """A human-readable label for the token"""
    name: String
    """The scopes this token is permitted to use"""
    scopes: [OAuthScopeEnum!]
    """
    Restrict token to specific orgs; null means all orgs the user belongs to
    """
    grantedOrgIds: [ID!]
    """
    Restrict token to specific teams; null means all teams the user belongs to
    """
    grantedTeamIds: [ID!]
    """
    Restrict token to specific pages; null means all pages the user can access
    """
    grantedPageIds: [ID!]
    """Expiration date; cannot be more than 1 year in the future"""
    expiresAt: DateTime
    """
    If true, sets revokedAt to the current timestamp, preventing further use
    """
    revoke: Boolean
  ): UpdatePersonalAccessTokenSuccess! @scope(name: USERS_WRITE)
  """Set the selected template for the upcoming retro meeting"""
  selectTemplate(selectedTemplateId: ID!, teamId: ID!): SelectTemplatePayload @scope(name: TEAMS_WRITE)
  """Update the default Slack channel where notifications are sent"""
  setDefaultSlackChannel(slackChannelId: ID!, teamId: ID!): SetDefaultSlackChannelPayload! @scope(name: TEAMS_WRITE)
  """
  Focus a specific reflection prompt so all participants see it highlighted. Pass null to unfocus.
  """
  setPhaseFocus(
    meetingId: ID!
    """The prompt to focus. Null to clear focus."""
    focusedPromptId: ID
  ): SetPhaseFocusPayload @scope(name: MEETINGS_WRITE)
  """Set or clear a timer for a meeting stage"""
  setStageTimer(
    """the id of the meeting"""
    meetingId: ID!
    """
    The time the timer is scheduled to go off (based on client clock), null if unsetting the timer
    """
    scheduledEndTime: DateTime
    """
    scheduledEndTime - now. Used to reconcile bad client clocks. Present for time limit, else null
    """
    timeRemaining: Float
  ): SetStageTimerPayload! @scope(name: MEETINGS_WRITE)
  """
  Configure which Slack notification events are sent to a channel for a team
  """
  setSlackNotification(slackChannelId: ID, slackNotificationEvents: [SlackNotificationEventEnum!]!, teamId: ID!): SetSlackNotificationPayload! @scope(name: TEAMS_WRITE)
  """Update the notification settings for a provider and team"""
  setTeamNotificationSetting(
    """The unique id for the setting"""
    id: ID!
    """Event type to modify"""
    event: SlackNotificationEventEnum!
    isEnabled: Boolean!
  ): SetTeamNotificationSettingPayload! @scope(name: TEAMS_WRITE)
  """Broadcast that the viewer started dragging a reflection"""
  startDraggingReflection(reflectionId: ID!, dragId: ID!, isSpotlight: Boolean): StartDraggingReflectionPayload @scope(name: MEETINGS_WRITE)
  """Start a new sprint poker (estimation) meeting for a team"""
  startSprintPoker(
    """The team starting the meeting"""
    teamId: ID!
    """The name of the meeting"""
    name: String
    """The gcal input if creating a gcal event"""
    gcalInput: CreateGcalEventInput
    """Set to true it ignore MAX_TEAM_UPGRADE_SUGGESTED"""
    ignoreSuggestedUpgrade: Boolean
  ): StartSprintPokerPayload! @scope(name: MEETINGS_WRITE)
  """
  Broadcast that the current user is highlighting or un-highlighting a task for other meeting participants
  """
  setTaskHighlight(taskId: ID!, meetingId: ID!, isHighlighted: Boolean!): SetTaskHighlightPayload! @scope(name: MEETINGS_WRITE)
  """Update an agenda item"""
  updateAgendaItem(
    """The updated item including an id, content, status, sortOrder"""
    updatedAgendaItem: UpdateAgendaItemInput!
  ): UpdateAgendaItemPayload @scope(name: TEAMS_WRITE)
  """Update the content of a comment"""
  updateCommentContent(
    commentId: ID!
    """A stringified TipTap JSONContent document containing thoughts"""
    content: String!
    meetingId: ID!
  ): UpdateCommentContentPayload @scope(name: COMMENTS_WRITE)
  """Update the scale used for a dimension in a template"""
  updatePokerTemplateDimensionScale(dimensionId: ID!, scaleId: ID!): UpdatePokerTemplateDimensionScalePayload! @scope(name: TEMPLATES_WRITE)
  """Update the label, numerical value or color of a scale value in a scale"""
  updatePokerTemplateScaleValue(scaleId: ID!, oldScaleValue: TemplateScaleInput!, newScaleValue: TemplateScaleInput!): UpdatePokerTemplateScaleValuePayload! @scope(name: TEMPLATES_WRITE)
  """Update a Team's Icebreaker in a new meeting"""
  updateNewCheckInQuestion(
    """ID of the Team which will have its Icebreaker updated"""
    meetingId: ID!
    """The Team's new Icebreaker"""
    checkInQuestion: String!
  ): UpdateNewCheckInQuestionPayload @scope(name: MEETINGS_WRITE)
  """
  Broadcast the current user's drag position to other meeting participants
  """
  updateDragLocation(input: UpdateDragLocationInput!): Boolean @scope(name: MEETINGS_WRITE)
  """Add or remove tasks from the sprint poker meeting's estimation backlog"""
  updatePokerScope(
    """the meeting with the estimate phases to modify"""
    meetingId: ID!
    """The list of items to add/remove to the estimate phase"""
    updates: [UpdatePokerScopeItemInput!]!
  ): UpdatePokerScopePayload! @scope(name: MEETINGS_WRITE)
  """Update the content of a reflection"""
  updateReflectionContent(
    reflectionId: ID!
    """A stringified TipTap JSONContent document containing thoughts"""
    content: String!
  ): UpdateReflectionContentPayload @scope(name: MEETINGS_WRITE)
  """Update the title of a reflection group"""
  updateReflectionGroupTitle(
    reflectionGroupId: ID!
    """The new title for the group"""
    title: String!
  ): UpdateReflectionGroupTitlePayload @scope(name: MEETINGS_WRITE)
  """
  Update the total votes and max votes per topic available to each participant in a retrospective
  """
  updateRetroMaxVotes(
    """The total number of votes for each participant"""
    totalVotes: Int!
    """
    The total number of votes for each participant to vote on a single topic
    """
    maxVotesPerGroup: Int!
    """the meeting to update"""
    meetingId: ID!
  ): UpdateRetroMaxVotesPayload! @scope(name: MEETINGS_WRITE)
  """Update a task with a change in content, ownership, or status"""
  updateTask(
    """The part of the site where the creation occurred"""
    area: AreaEnum
    """the updated task including the id, and at least one other field"""
    updatedTask: UpdateTaskInput!
  ): UpdateTaskPayload @scope(name: TASKS_WRITE)
  """Set or unset the due date of a task"""
  updateTaskDueDate(
    """The task id"""
    taskId: ID!
    """the new due date. if not a valid date, it will unset the due date"""
    dueDate: DateTime
  ): UpdateTaskDueDatePayload @scope(name: TASKS_WRITE)
  """Rename a team"""
  updateTeamName(
    """The input object containing the teamId and any modified fields"""
    updatedTeam: UpdatedTeamInput!
  ): UpdateTeamNamePayload @scope(name: TEAMS_WRITE)
  """Change the scope of a template"""
  updateTemplateScope(
    """The id of the template"""
    templateId: ID!
    """the new scope"""
    scope: SharingScopeEnum!
  ): UpdateTemplateScopePayload! @scope(name: TEMPLATES_WRITE)
  """Cast your vote for a reflection group"""
  voteForReflectionGroup(
    """true if the user wants to remove one of their votes"""
    isUnvote: Boolean
    reflectionGroupId: ID!
  ): VoteForReflectionGroupPayload @scope(name: MEETINGS_WRITE)
  """Cast a vote for the estimated points for a given dimension"""
  voteForPokerStory(
    meetingId: ID!
    """The stage that contains the dimension to vote for"""
    stageId: ID!
    """The label of the scaleValue to vote for. If null, remove the vote"""
    score: String
  ): VoteForPokerStoryPayload! @scope(name: MEETINGS_WRITE)
  """Progresses the stage dimension to the reveal & discuss step"""
  pokerRevealVotes(
    meetingId: ID!
    stageId: ID!
    """Set to true to ignore MAX_TEAM_UPGRADE_SUGGESTED"""
    ignoreSuggestedUpgrade: Boolean
  ): PokerRevealVotesPayload! @scope(name: MEETINGS_WRITE)
  """Remove all votes, the final vote, and reset the stage"""
  pokerResetDimension(meetingId: ID!, stageId: ID!): PokerResetDimensionPayload! @scope(name: MEETINGS_WRITE)
  """
  Broadcast that the current user started or stopped hovering over the poker scoring deck
  """
  pokerAnnounceDeckHover(
    meetingId: ID!
    stageId: ID!
    """true if the viewer has started hovering the deck, else false"""
    isHover: Boolean!
  ): PokerAnnounceDeckHoverPayload! @scope(name: MEETINGS_WRITE)
  """Move a scale value to an index"""
  movePokerTemplateScaleValue(
    scaleId: ID!
    """The label of the moving scale value"""
    label: String!
    """The index position where the scale value is moving to"""
    index: Int!
  ): MovePokerTemplateScaleValuePayload! @scope(name: TEMPLATES_WRITE)
  """Create a meeting member for a user"""
  joinMeeting(meetingId: ID!): JoinMeetingPayload! @scope(name: MEETINGS_WRITE)
  """Join a public Team directly without requiring an invitation"""
  joinTeam(
    """The ID of the team to join"""
    teamId: ID!
  ): JoinTeamPayload! @scope(name: TEAMS_WRITE)
  """Set whether the user is spectating poker meeting"""
  setPokerSpectate(
    meetingId: ID!
    """
    true if the viewer is spectating poker and does not want to vote. else false
    """
    isSpectating: Boolean!
  ): SetPokerSpectatePayload! @scope(name: MEETINGS_WRITE)
  """Save or remove a GitHub search query for a team's sprint poker backlog"""
  persistGitHubSearchQuery(
    """the team witht the settings we add the query to"""
    teamId: ID!
    """The query string as sent to GitHub"""
    queryString: String!
    """true if this query should be deleted"""
    isRemove: Boolean
  ): PersistGitHubSearchQueryPayload! @scope(name: TEAMS_WRITE)
  """Update a task estimate"""
  setTaskEstimate(taskEstimate: TaskEstimateInput!): SetTaskEstimatePayload! @scope(name: TASKS_WRITE)
  """Show or hide a drawer panel in the team dashboard"""
  toggleTeamDrawer(
    """the team to show/hide the drawer for"""
    teamId: ID!
    """
    The type of team drawer that the viewer is toggling. Null if closing the drawer.
    """
    teamDrawerType: TeamDrawer
  ): ToggleTeamDrawerPayload! @scope(name: TEAMS_WRITE)
  """
  Toggle a feature flag on or off for a specific owner (organization, team, or user). Admin-only.
  """
  toggleFeatureFlag(
    """The name of the feature flag to toggle"""
    featureName: String!
    """The organization ID if toggling for an org"""
    orgId: ID
    """The team ID if toggling for a team"""
    teamId: ID
    """The user ID if toggling for a user"""
    userId: ID
  ): ToggleFeatureFlagPayload! @scope(name: ORGS_WRITE)
  """Toggle AI features on or off for an organization"""
  toggleAIFeatures(
    """The id of the org being toggled"""
    orgId: ID!
  ): ToggleAIFeaturesPayload! @scope(name: ORGS_WRITE)
  """
  Toggle the team's privacy between public (joinable without invitation) and private
  """
  toggleTeamPrivacy(
    """The id of the team being toggled"""
    teamId: ID!
  ): ToggleTeamPrivacyPayload! @scope(name: TEAMS_WRITE)
  """Update how a parabol dimension maps to a GitHub label"""
  updateGitHubDimensionField(
    dimensionName: String!
    """The template string to map to a label"""
    labelTemplate: String!
    """The repo the issue lives on"""
    nameWithOwner: ID!
    """
    The meeting the update happend in. Returns a meeting object with updated serviceField
    """
    meetingId: ID!
  ): UpdateGitHubDimensionFieldPayload! @scope(name: MEETINGS_WRITE)
  createPoll(
    """The new poll including title and poll options"""
    newPoll: CreatePollInput!
  ): CreatePollPayload! @scope(name: MEETINGS_WRITE)
  """Adds a new Integration Provider configuration"""
  addIntegrationProvider(
    """The new Integration Provider"""
    input: AddIntegrationProviderInput!
  ): AddIntegrationProviderPayload! @scope(name: TEAMS_WRITE)
  """Update the Integration Provider settings"""
  updateIntegrationProvider(
    """The new Integration Provider"""
    provider: UpdateIntegrationProviderInput!
  ): UpdateIntegrationProviderPayload! @scope(name: TEAMS_WRITE)
  """Remove an Integration Provider, and any associated tokens"""
  removeIntegrationProvider(
    """Id of the Integration Provider to remove"""
    providerId: ID!
  ): RemoveIntegrationProviderPayload! @scope(name: TEAMS_WRITE)
  """Finish the team prompt meeting"""
  endTeamPrompt(
    """The meeting to end"""
    meetingId: ID!
  ): EndTeamPromptPayload! @scope(name: MEETINGS_WRITE)
  """Set the Azure DevOps field that the poker dimension should map to"""
  updateAzureDevOpsDimensionField(
    dimensionName: String!
    """The Azure DevOps field name that we should push estimates to"""
    fieldName: String!
    """The Azure DevOps instanceId the field lives on"""
    instanceId: ID!
    """The project the field lives on"""
    projectKey: ID!
    """
    The meeting the update happend in. Returns a meeting object with updated serviceField
    """
    meetingId: ID!
    """The work item type in Azure DevOps"""
    workItemType: ID!
  ): UpdateAzureDevOpsDimensionFieldPayload! @scope(name: MEETINGS_WRITE)
  """Adds a new poker template with a default dimension created."""
  addPokerTemplate(
    """The ID of the parent template, if this is a clone operation."""
    parentTemplateId: ID
    """The ID of the team for which the template is being created."""
    teamId: ID!
  ): AddPokerTemplatePayload! @scope(name: TEMPLATES_WRITE)
  """Adds a new reflect template with a default dimension created."""
  addReflectTemplate(
    """The ID of the parent template, if this is a clone operation."""
    parentTemplateId: ID
    """The ID of the team for which the template is being created."""
    teamId: ID!
  ): AddReflectTemplatePayload! @scope(name: TEMPLATES_WRITE)
  """
  Deactivate a user's billing seat. The user can still log in and will be automatically reactivated when they do.
  """
  inactivateUser(
    """the user to pause"""
    userId: ID!
  ): InactivateUserPayload @scope(name: USERS_WRITE)
  """
  Add the requesting user to multiple selected teams on the organization's domain
  """
  acceptRequestToJoinDomain(
    """DomainJoinRequest id"""
    requestId: ID!
    """Array of team ids"""
    teamIds: [ID!]!
  ): AcceptRequestToJoinDomainPayload! @scope(name: ORGS_WRITE)
  """Redeem an invitation token for a logged in user"""
  acceptTeamInvitation(
    """The invitation token or mass invitation code"""
    invitationToken: ID!
    """the notification clicked to accept, if any"""
    notificationId: ID
  ): AcceptTeamInvitationPayload! @scope(name: TEAMS_WRITE)
  """Restrict accepting team invites to a list of approved domains"""
  addApprovedOrganizationDomains(
    """The organization ID"""
    orgId: ID!
    """A list of domains or email addressed allowed to join the organization"""
    emailDomains: [String!]!
  ): AddApprovedOrganizationDomainsPayload! @scope(name: ORGS_WRITE)
  """
  Add or remove an emoji reaction (reactji) on a reactable item such as a reflection or comment
  """
  addReactjiToReactable(
    """The id of the reactable"""
    reactableId: ID!
    """The type of the reactable (e.g. reflection, comment)"""
    reactableType: ReactableEnum!
    """the id of the reactji to add"""
    reactji: String!
    """If true, remove the reaction, else add it"""
    isRemove: Boolean
    """The id of the meeting"""
    meetingId: ID!
  ): AddReactjiToReactablePayload! @scope(name: MEETINGS_WRITE)
  """Add an integration authorization for a specific team member"""
  addTeamMemberIntegrationAuth(
    providerId: ID!
    service: IntegrationProviderServiceEnum
    teamId: ID!
    """The OAuth2 code or personal access token. Null for webhook auth"""
    oauthCodeOrPat: ID
    """OAuth1 token verifier"""
    oauthVerifier: ID
    """The URL the OAuth2 token will be sent to. Null for webhook auth"""
    redirectUri: URL
  ): AddTeamMemberIntegrationAuthPayload! @scope(name: TEAMS_WRITE)
  """Watch the Google Meet Recordings folder for new transcripts and notes"""
  setupGoogleDriveWatch(
    """The team to associate the watch channel with"""
    teamId: ID!
  ): SetupGoogleDriveWatchSuccess! @scope(name: TEAMS_WRITE)
  """Link a Mattermost channel to a team to receive meeting notifications"""
  linkMattermostChannel(
    """The team to link the channel to"""
    teamId: ID!
    """The channel to link"""
    channelId: ID!
  ): LinkMattermostChannelPayload! @scope(name: TEAMS_WRITE)
  """Remove a previously linked channel from the team"""
  unlinkMattermostChannel(
    """The team to unlink the channel from"""
    teamId: ID!
    """The channel to unlink"""
    channelId: ID!
  ): UnlinkMattermostChannelPayload! @scope(name: TEAMS_WRITE)
  """Add the transcription bot to the Zoom meeting"""
  addTranscriptionBot(meetingId: ID!, videoMeetingURL: String!): AddTranscriptionBotPayload! @scope(name: MEETINGS_WRITE)
  """Creates suggested reflection groups using OpenAI"""
  autogroup(meetingId: ID!): AutogroupPayload! @scope(name: MEETINGS_WRITE)
  """Batch archive tasks"""
  batchArchiveTasks(
    """ids of the tasks to archive"""
    taskIds: [ID!]!
  ): BatchArchiveTasksPayload! @scope(name: TASKS_WRITE)
  """
  Admin-only: create an auth token to impersonate a given user for troubleshooting
  """
  createImposterToken(
    """The target userId to impersonate"""
    userId: ID
    """The email address of the user to impersonate"""
    email: Email
  ): CreateImposterTokenPayload! @scope(name: USERS_WRITE)
  """Create the Stripe subscription for the given org"""
  createStripeSubscription(orgId: ID!, paymentMethodId: ID!): CreateStripeSubscriptionPayload! @scope(name: ORGS_WRITE)
  """Sign up or login using Google"""
  loginWithGoogle(
    """The code provided from the OAuth2 flow"""
    code: ID!
    """optional pseudo id created before they were a user"""
    pseudoId: ID
    """if present, the user is also joining a team"""
    invitationToken: ID
    """query params on the login page, used to maybe add feature flag"""
    params: String!
  ): UserLogInPayload! @scope(name: USERS_WRITE)
  """Sign up or login using Microsoft"""
  loginWithMicrosoft(
    """The code provided from the OAuth2 flow"""
    code: ID!
    """optional pseudo id created before they were a user"""
    pseudoId: ID
    """if present, the user is also joining a team"""
    invitationToken: ID
    """query params on the login page, used to maybe add feature flag"""
    params: String!
  ): UserLogInPayload! @scope(name: USERS_WRITE)
  """Login using an email address and password"""
  loginWithPassword(email: ID!, password: String!): UserLogInPayload! @scope(name: USERS_WRITE)
  """Sign out the current user"""
  signOut: Boolean! @scope(name: USERS_WRITE)
  """Refresh the session token"""
  refreshSession: Boolean! @scope(name: USERS_WRITE)
  """
  Modify the tone of an AI-generated draft icebreaker question for a check-in meeting. Only visible to the facilitator before it is applied. modifyType options: EXCITING, FUNNY, SERIOUS.
  """
  modifyCheckInQuestion(meetingId: ID!, checkInQuestion: String!, modifyType: ModifyType!): ModifyCheckInQuestionPayload! @scope(name: MEETINGS_WRITE)
  """
  Save a search query for a team's integration provider (e.g. Jira Server) for reuse in sprint poker
  """
  persistIntegrationSearchQuery(teamId: ID!, service: IntegrationProviderServiceEnum!, providerId: ID, jiraServerSearchQuery: JiraServerSearchQueryInput): PersistIntegrationSearchQueryPayload! @scope(name: TEAMS_WRITE)
  """Remove the approved domains for a given organization"""
  removeApprovedOrganizationDomains(
    """The ID for the organization to remove the restriction from"""
    orgId: ID!
    """The list of emails and/or domains to unrestrict from the org"""
    emailDomains: [String!]!
  ): RemoveApprovedOrganizationDomainsPayload! @scope(name: ORGS_WRITE)
  """Remove a saved search query from a team's integration provider"""
  removeIntegrationSearchQuery(
    """integration search query ID"""
    id: ID!
    teamId: ID!
  ): RemoveIntegrationSearchQueryPayload! @scope(name: TEAMS_WRITE)
  """Remove the integrated auth for a given team member"""
  removeTeamMemberIntegrationAuth(
    """The Integration Provider service name related to the token"""
    service: IntegrationProviderServiceEnum!
    """The team id related to the token"""
    teamId: ID!
  ): RemoveTeamMemberIntegrationAuthPayload! @scope(name: TEAMS_WRITE)
  """
  Send a request to join the organizations associated with the current user's email domain
  """
  requestToJoinDomain: RequestToJoinDomainPayload! @scope(name: ORGS_WRITE)
  """
  Resets the reflection groups to the state they were in before autogrouping
  """
  resetReflectionGroups(meetingId: ID!): ResetReflectionGroupsPayload! @scope(name: MEETINGS_WRITE)
  """Remove a reflection from its group, placing it into its own new group"""
  ungroupReflection(reflectionGroupId: ID, reflectionId: ID): UngroupReflectionSuccess! @scope(name: MEETINGS_WRITE)
  """Simultaneously reveal all hidden team health votes in a meeting stage"""
  revealTeamHealthVotes(meetingId: ID!, stageId: ID!): RevealTeamHealthVotesPayload! @scope(name: MEETINGS_WRITE)
  """
  Update configurable settings for a meeting type, including icebreaker phase, team health phase, review tasks phase, reflection anonymity, and video meeting URL
  """
  setMeetingSettings(
    settingsId: ID!
    """true to turn icebreaker phase on, false to turn it off"""
    checkinEnabled: Boolean
    """true to turn team health phase on, false to turn it off"""
    teamHealthEnabled: Boolean
    """
    true to turn the review tasks (updates) phase on, false to turn it off. Only meaningful for retrospective meetings.
    """
    reviewPastTasksEnabled: Boolean
    """disables anonymity of reflections"""
    disableAnonymity: Boolean
    """the url of the video meeting, e.g. the Zoom link"""
    videoMeetingURL: String
  ): SetMeetingSettingsPayload! @scope(name: MEETINGS_WRITE)
  """Set the Jira fields to display on the estimate header card"""
  setJiraDisplayFieldIds(teamId: ID!, jiraDisplayFieldIds: [String!]!): SetJiraDisplayFieldIdsPayload! @scope(name: TEAMS_WRITE)
  """Set the music being played in the meeting"""
  setMeetingMusic(meetingId: ID!, trackSrc: String, isPlaying: Boolean!): SetMeetingMusicPayload! @scope(name: MEETINGS_WRITE)
  """Update the role of the org user"""
  setOrgUserRole(
    orgId: ID!
    userId: ID!
    """
    The role to set the user to, e.g. billing leader. Null to remove the role
    """
    role: OrgUserRole
  ): SetOrgUserRolePayload! @scope(name: ORGS_WRITE)
  setTeamHealthVote(meetingId: ID!, stageId: ID!, label: String!): SetTeamHealthVotePayload! @scope(name: MEETINGS_WRITE)
  """Shares retro discussion to integration"""
  shareTopic(
    """Discussion stage id"""
    stageId: ID!
    """meetingId"""
    meetingId: ID!
    """Integration channelId"""
    channelId: ID!
  ): ShareTopicPayload! @scope(name: MEETINGS_WRITE)
  """Sign up using an email address and password"""
  signUpWithPassword(
    email: ID!
    password: String!
    """optional pseudo id created before they were a user"""
    pseudoId: ID
    """used to determine what suggested actions to create"""
    invitationToken: ID
    """query params on the login page, used to maybe add feature flag"""
    params: String!
  ): UserLogInPayload! @scope(name: USERS_WRITE)
  """Start a new meeting"""
  startCheckIn(
    """The team starting the meeting"""
    teamId: ID!
    """The name of the meeting"""
    name: String
    """The gcal input if creating a gcal event"""
    gcalInput: CreateGcalEventInput
    """Set to true it ignore MAX_TEAM_UPGRADE_SUGGESTED"""
    ignoreSuggestedUpgrade: Boolean
  ): StartCheckInPayload! @scope(name: MEETINGS_WRITE)
  """Start a new meeting"""
  startRetrospective(
    """The team starting the meeting"""
    teamId: ID!
    """Name of the meeting or series"""
    name: String
    """The recurrence rule for the meeting series in RRULE format"""
    rrule: RRule
    """The gcal input if creating a gcal event"""
    gcalInput: CreateGcalEventInput
    """Set to true it ignore MAX_TEAM_UPGRADE_SUGGESTED"""
    ignoreSuggestedUpgrade: Boolean
  ): StartRetrospectivePayload! @scope(name: MEETINGS_WRITE)
  """Starts a new team prompt meeting"""
  startTeamPrompt(
    """Id of the team starting the meeting"""
    teamId: ID!
    """
    Meeting or series name, by default "Standup"
    """
    name: String
    """The recurrence rule for the meeting series in RRULE format"""
    rrule: RRule
    """
    The gcal input if creating a gcal event. If not provided, no gcal event will be created
    """
    gcalInput: CreateGcalEventInput
    """Set to true it ignore MAX_TEAM_UPGRADE_SUGGESTED"""
    ignoreSuggestedUpgrade: Boolean
  ): StartTeamPromptPayload! @scope(name: MEETINGS_WRITE)
  """Add or remove the template to the user's favorite templates"""
  toggleFavoriteTemplate(
    """The ID of the template to be toggled as a favorite"""
    templateId: ID!
  ): ToggleFavoriteTemplateSuccess! @scope(name: TEMPLATES_WRITE)
  """
  Toggles the sendSummaryEmail value on the User object which determines whether summary emails are sent to the user
  """
  toggleSummaryEmail: ToggleSummaryEmailPayload! @scope(name: USERS_WRITE)
  """
  Toggles the sendPageInvitationEmail value on the User object which determines whether page invitation emails are sent to the user
  """
  togglePageInvitationEmail: TogglePageInvitationEmailPayload! @scope(name: USERS_WRITE)
  """Update the autoJoin value for a set of teams"""
  updateAutoJoin(
    """The team ids to update"""
    teamIds: [ID!]!
    """The new autoJoin value for the teams"""
    autoJoin: Boolean!
  ): UpdateAutoJoinPayload! @scope(name: TEAMS_WRITE)
  """Update an org's credit card"""
  updateCreditCard(
    """The id of the org that is updating their credit card"""
    orgId: ID!
    """The id of the new payment method from Stripe"""
    paymentMethodId: ID!
  ): UpdateCreditCardPayload! @scope(name: ORGS_WRITE)
  """Update how a parabol dimension maps to a GitLab label"""
  updateGitLabDimensionField(
    """The Poker dimension that we're updating, e.g. story points"""
    dimensionName: String!
    """The template string to map to a label, e.g. __comment"""
    labelTemplate: String!
    """
    The meeting the update happend in. Returns a meeting object with updated serviceField.
    """
    meetingId: ID!
    """The id of the project the issue belongs to"""
    projectId: Int!
  ): UpdateGitLabDimensionFieldPayload! @scope(name: MEETINGS_WRITE)
  """Update how a parabol dimension maps to a Linear label"""
  updateLinearDimensionField(
    """The Poker dimension that we're updating, e.g. story points"""
    dimensionName: String!
    """The template string to map to a label, e.g. __comment"""
    labelTemplate: String!
    """
    The meeting the update happend in. Returns a meeting object with updated serviceField.
    """
    meetingId: ID!
    """The id of the project the issue belongs to"""
    repoId: String!
  ): UpdateLinearDimensionFieldPayload! @scope(name: MEETINGS_WRITE)
  """Set the jira field that the poker dimension should map to"""
  updateJiraDimensionField(
    """Id of the parabol task on which the dimension was updated"""
    taskId: ID!
    """Dimension name from the template used"""
    dimensionName: String!
    """The jira field id that we should push estimates to"""
    fieldId: ID!
    """
    The meeting the update happend in. Returns a meeting object with updated serviceField
    """
    meetingId: ID!
  ): UpdateDimensionFieldPayload! @scope(name: MEETINGS_WRITE)
  """Set the JiraServer field that the poker dimension should map to`,"""
  updateJiraServerDimensionField(
    dimensionName: String!
    """The Jira Data Center field name that we should push estimates to"""
    fieldName: ID!
    """The Jira Data Center issue type for which to set the dimension"""
    issueType: ID!
    """Project id for this setting"""
    projectId: ID!
    """
    The meeting the update happend in. Returns a meeting object with updated serviceField
    """
    meetingId: ID!
  ): UpdateDimensionFieldPayload! @scope(name: MEETINGS_WRITE)
  """Describe the mutation here"""
  updateMeetingPrompt(
    """The meeting to update the prompt"""
    meetingId: ID!
    """The updated prompt"""
    newPrompt: String!
  ): UpdateMeetingPromptPayload! @scope(name: MEETINGS_WRITE)
  """Update a meeting template"""
  updateMeetingTemplate(
    """The id of the meeting"""
    meetingId: ID!
    """The id of the meeting template"""
    templateId: ID!
  ): UpdateMeetingTemplatePayload! @scope(name: MEETINGS_WRITE)
  """Update an with a change in name, avatar"""
  updateOrg(
    """the updated org including the id, and at least one other field"""
    updatedOrg: UpdateOrgInput!
  ): UpdateOrgPayload! @scope(name: ORGS_WRITE)
  """
  Updates the recurrence settings for a meeting
  1. When the meeting is not recurring, this will start the meeting recurring with the given recurrenceRule
  2. When the meeting is recurring and the provided recurrenceRule is defined, this will update the recurrence rule with the given recurrenceRule
  3. When the meeting is recurring and the provided recurrenceRule is null, this will stop the meeting from recurring
  """
  updateRecurrenceSettings(
    """ID of the meeting to update recurrence settings for"""
    meetingId: ID!
    """New meeting series name"""
    name: String
    """The recurrence rule for the meeting series in RRULE format"""
    rrule: RRule
  ): UpdateRecurrenceSettingsPayload! @scope(name: MEETINGS_WRITE)
  """
  Updates a meeting series directly by its ID. Used for managing scheduled-only series
  (where no meeting has spawned yet) and editing/cancelling a series from the dashboard
  rather than from inside a meeting.
  - Pass a non-null rrule to update the recurrence (also restarts a cancelled series)
  - Pass null rrule to cancel the series
  """
  updateMeetingSeries(
    """ID of the meeting series to update"""
    meetingSeriesId: ID!
    """New meeting series name"""
    name: String
    """
    The recurrence rule for the meeting series in RRULE format; null cancels the series
    """
    rrule: RRule
  ): UpdateMeetingSeriesPayload! @scope(name: MEETINGS_WRITE)
  """Updates the mainCategory for the given template"""
  updateTemplateCategory(
    """The ID of the template"""
    templateId: ID!
    """The new category for the template"""
    mainCategory: String!
  ): UpdateTemplateCategoryPayload! @scope(name: TEMPLATES_WRITE)
  updateUserProfile(
    """
    The input object containing the user profile fields that can be changed
    """
    updatedUser: UpdateUserProfileInput!
  ): UpdateUserProfilePayload @scope(name: USERS_WRITE)
  """
  Upload the IdP Metadata file for an org for those who cannot self-host the file
  """
  uploadIdPMetadata(
    """the XML Metadata file for the IdP"""
    file: File!
    """The orgId to upload the IdP Metadata for"""
    orgId: ID!
  ): UploadIdPMetadataPayload! @scope(name: ORGS_WRITE)
  """Upload an image for an org avatar"""
  uploadOrgImage(
    """the org avatar image file"""
    file: File!
    """The org id to upload an avatar for"""
    orgId: ID!
  ): UpdateOrgPayload! @scope(name: ORGS_WRITE)
  """Take any asset & host it in the file store"""
  embedUserAsset(
    """the asset URL"""
    url: URL!
    """the scope of who can access the file, either user or page"""
    scope: AssetScopeEnum!
    """The client ID of the scope, e.g. userId, teamId, orgId, pageKey"""
    scopeKey: ID!
  ): UploadUserAssetPayload @scope(name: USERS_WRITE)
  """Upload any asset owned by a user"""
  uploadUserAsset(
    """the asset file"""
    file: File!
    """the scope of who can access the file, either user or page"""
    scope: AssetScopeEnum!
    """The client ID of the scope, e.g. userId, teamId, orgId, pageKey"""
    scopeKey: ID!
  ): UploadUserAssetPayload @scope(name: USERS_WRITE)
  """Upload an image for a user avatar"""
  uploadUserImage(
    """the user avatar image file"""
    file: File!
  ): UpdateUserProfilePayload @scope(name: USERS_WRITE)
  """upsert the content of a team prompt response"""
  upsertTeamPromptResponse(
    """The id of the team prompt response to upsert"""
    teamPromptResponseId: ID
    """The id of the team prompt meeting"""
    meetingId: ID!
    """The stringified content of the team prompt response"""
    content: String!
  ): UpsertTeamPromptResponsePayload! @scope(name: MEETINGS_WRITE)
  """Verify an email address and sign in if not already a user"""
  verifyEmail(
    """The 48-byte url-safe base64 encoded verification token"""
    verificationToken: ID!
  ): UserLogInPayload! @scope(name: USERS_WRITE)
  """Update the role-based access for a page"""
  updatePageAccess(
    """The page to update access for"""
    pageId: ID!
    subjectType: PageSubjectEnum!
    subjectId: ID!
    role: PageRoleEnum
    """True if this mutation can unlink the pageId from its parent"""
    unlinkApproved: Boolean
  ): UpdatePageAccessPayload @scope(name: PAGES_WRITE)
  """Requests access to a page"""
  requestPageAccess(
    """The id of the page to request access to"""
    pageId: ID!
    """Reason for requesting access"""
    reason: String!
    """The requested access role"""
    role: PageRoleEnum!
  ): Boolean @scope(name: PAGES_WRITE)
  """
  Update the page sortOrder, teamId, or parentPageId and adjust access accordingly
  """
  updatePage(
    """The ID of the page to update"""
    pageId: ID!
    """The new sort order, as a fractional index"""
    sortOrder: String!
    """The section the page is being moved from"""
    sourceSection: PageSectionEnum
    """The section the page is being moved to"""
    targetSection: PageSectionEnum
    """The new teamId, if moved to a team"""
    teamId: ID
    """true to revoke access for all but the mutator"""
    makePrivate: Boolean
  ): UpdatePagePayload! @scope(name: PAGES_WRITE)
  """link or unlink a page to its parent"""
  updatePageParentLink(
    """The ID of the page to update"""
    pageId: ID!
    """True to re-link, false to unlink"""
    isParentLinked: Boolean!
  ): UpdatePagePayload @scope(name: PAGES_WRITE)
  updateTeamSortOrder(
    teamId: ID!
    """The new sort order as a fractional index"""
    sortOrder: String!
  ): UpdateTeamSortOrderPayload @scope(name: TEAMS_WRITE)
  """Move a page to the trash"""
  archivePage(
    pageId: ID!
    """The action to take on the page"""
    action: ArchivePageActionEnum!
  ): ArchivePagePayload @scope(name: PAGES_WRITE)
}

"""The result of the facilitator navigating to a different meeting stage"""
type NavigateMeetingPayload {
  """Error information if the mutation failed"""
  error: StandardMutationError
  """The updated meeting after navigation"""
  meeting: NewMeeting
  """The stage that the facilitator is now on"""
  facilitatorStage: NewMeetingStage
  """The stage that the facilitator left"""
  oldFacilitatorStage: NewMeetingStage
  """Additional details triggered by completing certain phases"""
  phaseComplete: PhaseCompletePayload
  """The stages that were unlocked by navigating"""
  unlockedStages: [NewMeetingStage!]
}

"""The latest feature released by Parabol"""
type NewFeatureBroadcast {
  id: ID!
  """The text of the action button in the snackbar"""
  actionButtonCopy: String!
  """The description of the new feature"""
  snackbarMessage: String!
  """The permalink to the blog post describing the new feature"""
  url: String!
}

"""
A Parabol team meeting, representing a single occurrence of any meeting type (check-in, retro, poker, standup)
"""
interface NewMeeting {
  """The unique meeting ID"""
  id: ID!
  """
  The viewer's most recently generated AI inspiration items for a given integration service,
  cached for a short window. Empty if none have been generated recently.
  """
  inspirationItems(service: ServiceEnum!): [InspirationItem!]!
  """The timestamp the meeting was created"""
  createdAt: DateTime!
  """
  The id of the user that created the meeting, null if user was hard deleted
  """
  createdBy: ID
  """The user that created the meeting, null if user was hard deleted"""
  createdByUser: User @scope(name: USERS_READ)
  """The timestamp the meeting officially ended"""
  endedAt: DateTime
  """The location of the facilitator in the meeting"""
  facilitatorStageId: ID!
  """The userId (or anonymousId) of the most recent facilitator"""
  facilitatorUserId: ID!
  """The facilitator team member"""
  facilitator: TeamMember! @scope(name: TEAMS_READ)
  """Is this locked for starter plans?"""
  locked: Boolean!
  """The team members that were active during the time of the meeting"""
  meetingMembers: [MeetingMember!]!
  """The auto-incrementing meeting number for the team"""
  meetingNumber: Int!
  """The id of the meeting series this meeting belongs to"""
  meetingSeriesId: ID
  """
  The meeting series this meeting is associated with if the meeting is recurring
  """
  meetingSeries: MeetingSeries
  """The type of meeting (action, retrospective, poker, teamPrompt)"""
  meetingType: MeetingTypeEnum!
  """The name of the meeting"""
  name: String!
  """The organization this meeting belongs to"""
  organization: Organization! @scope(name: ORGS_READ)
  """
  The phases the meeting will go through, including all phase-specific state
  """
  phases: [NewMeetingPhase!]!
  """
  If meeting has a meeting series associated, this is the time the meeting will end
  """
  scheduledEndTime: DateTime
  """
  The OpenAI generated summary of all the content in the meeting, such as reflections, tasks, and comments. Undefined if the user doesnt have access to the feature or it's unavailable in this meeting type`
  """
  summary: String
  """The time the meeting summary was emailed to the team"""
  summarySentAt: DateTime
  """The team that ran the meeting"""
  teamId: ID!
  """The team that ran the meeting"""
  team: Team! @scope(name: TEAMS_READ)
  """The last time a meeting was updated (stage completed, finished, etc)"""
  updatedAt: DateTime
  """The meeting member of the viewer"""
  viewerMeetingMember: MeetingMember
  """The ID of the page containing the meeting summary, if one was created"""
  summaryPageId: ID
}

"""The result of checking a member in or out of a meeting"""
type NewMeetingCheckInPayload {
  """Error information if the mutation failed"""
  error: StandardMutationError
  """The updated meeting member"""
  meetingMember: MeetingMember
  """The meeting that was updated"""
  meeting: NewMeeting
}

"""
A phase within a meeting, containing one or more stages that participants move through
"""
interface NewMeetingPhase {
  """The unique phase ID"""
  id: ID!
  """The meeting this phase belongs to"""
  meetingId: ID!
  """The team this phase belongs to"""
  teamId: ID!
  """The type of phase"""
  phaseType: NewMeetingPhaseTypeEnum!
  """The stages that make up this phase"""
  stages: [NewMeetingStage!]!
}

"""The phase of the meeting"""
enum NewMeetingPhaseTypeEnum {
  """Waiting room before the meeting officially starts"""
  lobby
  """Check-in round where each participant gives a brief status"""
  checkin
  """Updates round in a check-in meeting"""
  updates
  """First call for agenda items in a check-in meeting"""
  firstcall
  """Discussion of agenda items in a check-in meeting"""
  agendaitems
  """Last call for additional agenda items"""
  lastcall
  """Reflection phase in a retrospective where participants add cards"""
  reflect
  """
  Grouping phase in a retrospective where similar reflections are clustered
  """
  group
  """Voting phase in a retrospective where participants upvote groups"""
  vote
  """
  Discussion phase in a retrospective where groups are discussed one at a time
  """
  discuss
  """Summary phase shown at the end of any meeting type"""
  SUMMARY
  """Scope phase in a Poker meeting for selecting issues to estimate"""
  SCOPE
  """
  Estimation phase in a Poker meeting where participants vote on story points
  """
  ESTIMATE
  """
  Responses phase in a standup meeting where team members write their updates
  """
  RESPONSES
  """Team health check phase for pulse-check voting"""
  TEAM_HEALTH
}

"""
An instance of a meeting phase item. On the client, this usually represents a single view
"""
interface NewMeetingStage {
  """The unique stage ID"""
  id: ID!
  """The datetime the stage was completed"""
  endAt: DateTime
  """The ID of the meeting this stage belongs to"""
  meetingId: ID!
  """The meeting this stage belongs to"""
  meeting: NewMeeting!
  """true if the facilitator has completed this stage, else false"""
  isComplete: Boolean!
  """true if any meeting participant can navigate to this stage"""
  isNavigable: Boolean!
  """true if the facilitator can navigate to this stage"""
  isNavigableByFacilitator: Boolean!
  """The phase this stage belongs to"""
  phase: NewMeetingPhase
  """The type of the phase"""
  phaseType: NewMeetingPhaseTypeEnum
  """The datetime the stage was started"""
  startAt: DateTime
  """Number of times the facilitator has visited this stage"""
  viewCount: Int
  """
  true if a time limit is set, false if end time is set, null if neither is set
  """
  isAsync: Boolean
  """true if the viewer is ready to advance, else false"""
  isViewerReady: Boolean!
  """User ids of those who are ready to advance to the next stage"""
  readyUserIds: [ID!]!
  """
  The datetime the phase is scheduled to be finished, null if no time limit or end time is set
  """
  scheduledEndTime: DateTime
  """
  The suggested ending datetime for a phase to be completed async, null if not enough data to make a suggestion
  """
  suggestedEndTime: DateTime
  """
  The suggested time limit for a phase to be completed together, null if not enough data to make a suggestion
  """
  suggestedTimeLimit: Float
  """The team this stage belongs to"""
  teamId: ID!
  """
  The number of milliseconds left before the scheduled end time. Useful for unsynced client clocks. null if scheduledEndTime is null
  """
  timeRemaining: Float
  """
  The 0-based position of this stage within its phase, ordered by sortOrder.
  Use stageIdx + 1 to construct deep-link URLs such as /meet/:meetingId/:phaseUrlSlug/:n.
  """
  stageIdx: Int!
}

"""
An instance of a meeting phase item. On the client, this usually represents a single view
"""
interface NewMeetingTeamMemberStage {
  """The meeting member that is the focus for this phase item"""
  meetingMember: MeetingMember!
  """The ID of the team member who is the focus of this stage"""
  teamMemberId: ID!
  """The team member that is the focus for this phase item"""
  teamMember: TeamMember!
}

"""Input for creating a new team within an organization"""
input NewTeamInput {
  """The name of the team"""
  name: String!
  """The ID of the organization that the team belongs to"""
  orgId: ID!
  """
  Whether the team is public (can be found and joined) or private (invite-only)
  """
  isPublic: Boolean!
}

"""
A notification sent to a user to inform them of an event that requires their attention
"""
interface Notification {
  """The unique notification ID"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  """
  The notification type, used to determine which concrete type to resolve
  """
  type: NotificationEnum!
  """The ID of the user who should see this notification"""
  userId: ID!
}

"""A connection to a list of items."""
type NotificationConnection {
  """Page info with cursors coerced to ISO8601 dates"""
  pageInfo: PageInfoDateCursor
  """A list of edges."""
  edges: [NotificationEdge!]!
}

"""An edge in a connection."""
type NotificationEdge {
  """The item at the end of the edge"""
  node: Notification!
  """Cursor for date-based pagination"""
  cursor: DateTime
}

"""The kind of notification"""
enum NotificationEnum {
  """The viewer was mentioned in a discussion thread"""
  DISCUSSION_MENTIONED
  """The viewer was removed from a team"""
  KICKED_OUT
  """A payment method was rejected by Stripe"""
  PAYMENT_REJECTED
  """The viewer was promoted to a billing leader role"""
  PROMOTE_TO_BILLING_LEADER
  """The viewer received a team invitation"""
  TEAM_INVITATION
  """A team the viewer was on has been archived"""
  TEAM_ARCHIVED
  """The viewer was assigned to or mentioned in a task"""
  TASK_INVOLVES
  """A timed meeting stage has reached its time limit"""
  MEETING_STAGE_TIME_LIMIT_END
  """The viewer was mentioned in a standup response"""
  RESPONSE_MENTIONED
  """The viewer was mentioned somewhere in a meeting"""
  MENTIONED
  """Someone replied to a standup response the viewer authored"""
  RESPONSE_REPLIED
  """The organization is approaching its team limit and may be locked soon"""
  TEAMS_LIMIT_REMINDER
  """
  The viewer is prompted to join an organization that matches their email domain
  """
  PROMPT_TO_JOIN_ORG
  """
  An org admin received a request from someone who wants to join their organization
  """
  REQUEST_TO_JOIN_ORG
  """The organization has exceeded its team limit and is now locked"""
  TEAMS_LIMIT_EXCEEDED
  """The viewer was granted access to a page"""
  PAGE_ACCESS_GRANTED
  """A page owner received a request to access their page"""
  PAGE_ACCESS_REQUESTED
}

"""
A notification sent to a facilitator that the stage time limit has ended
"""
type NotificationMeetingStageTimeLimitEnd implements Notification & TeamNotification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The ID of the user who should see this notification"""
  userId: ID!
  """The ID of the meeting whose stage time limit expired"""
  meetingId: ID!
  """The meeting that had the time limit expire"""
  meeting: NewMeeting!
}

"""The status of the notification interaction"""
enum NotificationStatusEnum {
  UNREAD
  READ
  CLICKED
}

type NotificationSubscriptionPayload {
  fieldName: String!
  AcceptTeamInvitationPayload: AcceptTeamInvitationPayload
  AddNewFeaturePayload: AddNewFeaturePayload
  AddOrgPayload: AddOrgPayload
  AddTeamPayload: AddTeamPayload
  ArchiveTimelineEventSuccess: ArchiveTimelineEventSuccess
  SetNotificationStatusPayload: SetNotificationStatusPayload
  CreateTaskPayload: CreateTaskPayload
  DeleteTaskPayload: DeleteTaskPayload
  DisconnectSocketPayload: DisconnectSocketPayload
  EndCheckInSuccess: EndCheckInSuccess
  EndRetrospectiveSuccess: EndRetrospectiveSuccess
  InvalidateSessionsPayload: InvalidateSessionsPayload
  InviteToTeamPayload: InviteToTeamPayload
  MeetingStageTimeLimitPayload: MeetingStageTimeLimitPayload
  RemoveOrgUsersSuccess: RemoveOrgUsersSuccess
  RemoveTeamMemberPayload: RemoveTeamMemberPayload
  StripeFailPaymentPayload: StripeFailPaymentPayload
  PersistJiraSearchQuerySuccess: PersistJiraSearchQuerySuccess
  User: User
  AuthTokenPayload: AuthTokenPayload
  PersistGitHubSearchQuerySuccess: PersistGitHubSearchQuerySuccess
  JiraServerIssue: JiraServerIssue
  AddedNotification: AddedNotification
  JiraIssue: JiraIssue
  UpdatedNotification: UpdatedNotification
  RemoveIntegrationSearchQuerySuccess: RemoveIntegrationSearchQuerySuccess
  PersistIntegrationSearchQuerySuccess: PersistIntegrationSearchQuerySuccess
  ToggleFeatureFlagSuccess: ToggleFeatureFlagSuccess
  ArchivePagePayload: ArchivePagePayload
  CreatePagePayload: CreatePagePayload
  UpdatePagePayload: UpdatePagePayload
  UpdatePageAccessPayload: UpdatePageAccessPayload
}

"""A notification sent to a user that was invited to a new team"""
type NotificationTeamInvitation implements Notification & TeamNotification {
  """The ID of the team the user was invited to"""
  teamId: ID!
  """The ID of the team invitation that triggered this notification"""
  invitationId: ID!
  """The invitation that triggered this notification"""
  invitation: TeamInvitation!
  """The team the user was invited to"""
  team: Team!
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The ID of the user who should see this notification"""
  userId: ID!
}

"""
A notification sent when the viewer is mentioned in a meeting discussion thread
"""
type NotifyDiscussionMentioned implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The userId that should see this notification"""
  userId: ID!
  """The id of the user that replied to the response, null if anonymous"""
  authorId: ID
  """The user that replied to the response, null if anonymous"""
  author: User
  """The id of the meeting the response was replied to in."""
  meetingId: String!
  """The meeting the response was replied to in."""
  meeting: NewMeeting!
  """The id of the reply comment"""
  commentId: ID!
  """The reply comment"""
  comment: Comment!
  """The id of the discussion"""
  discussionId: ID!
  """The discussion"""
  discussion: Discussion!
}

"""A notification sent to someone who was just kicked off a team"""
type NotifyKickedOut implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The ID of the user who should see this notification"""
  userId: ID!
  """the user that evicted recipient"""
  evictor: User!
  """The name of the team the user was removed from"""
  teamName: String!
  """The teamId the user was kicked out of"""
  teamId: ID!
  """The team the task is on"""
  team: Team!
}

type NotifyMentioned implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """Sender name, null if anonymous"""
  senderName: String
  """Sender picture"""
  senderPicture: URL
  """The userId that should see this notification"""
  userId: ID!
  """The id of the meeting the user was mentioned in"""
  meetingId: String!
  """Meeting name"""
  meetingName: String!
  """Linked retro reflection if mentioned in a reflection"""
  retroReflection: RetroReflection
  """Linked discussion stage number"""
  retroDiscussStageIdx: Int
}

type NotifyPageAccessGranted implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """Id of the user that got granted access"""
  userId: ID!
  """Name of the user who granted access"""
  ownerName: String!
  """Picture of the user who granted access"""
  ownerPicture: URL
  """The granted role"""
  role: PageRoleEnum!
  """The pageId that was granted access"""
  pageId: ID!
  """The page that was granted access to"""
  page: PagePreview!
}

type NotifyPageAccessRequested implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """Id of the user from whom access is requested"""
  userId: ID!
  """Email of the requesting user"""
  email: String!
  """Name of the requesting User"""
  name: String
  """Picture of the requesting user"""
  picture: URL
  """The role requested"""
  role: PageRoleEnum!
  """The pageId that was requested access for"""
  pageId: ID!
  """The page that was requested access for"""
  page: PagePreview!
}

"""A notification sent to a user when their payment has been rejected"""
type NotifyPaymentRejected implements Notification {
  """The organization whose payment was rejected"""
  organization: Organization!
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The ID of the user who should see this notification"""
  userId: ID!
}

"""
A notification alerting the user that they have been promoted (to team or org leader)
"""
type NotifyPromoteToOrgLeader implements Notification {
  """The organization in which the viewer was promoted"""
  organization: Organization!
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The ID of the user who should see this notification"""
  userId: ID!
}

type NotifyPromptToJoinOrg implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The userId that should see this notification"""
  userId: ID!
  """Active domain"""
  activeDomain: String!
}

type NotifyRequestToJoinOrg implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The userId that should see this notification"""
  userId: ID!
  """Email of the user who made the request"""
  email: String!
  """Name of the user who made the request"""
  name: String
  """Picture of the user who made the request"""
  picture: URL
  """Request created by userId"""
  requestCreatedBy: ID!
  """Attached join request id"""
  domainJoinRequestId: ID!
}

type NotifyResponseMentioned implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The userId that should see this notification"""
  userId: ID!
  """The id of the response the user was mentioned in."""
  responseId: String!
  """The id of the meeting the user was mentioned in."""
  meetingId: String!
  """The response the user was mentioned in."""
  response: TeamPromptResponse!
  """The meeting the user was mentioned in."""
  meeting: TeamPromptMeeting!
}

type NotifyResponseReplied implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The userId that should see this notification"""
  userId: ID!
  """The id of the user that replied to the response, null if anonymous"""
  authorId: ID
  """The user that replied to the response, null if anonymous"""
  author: User
  """The id of the meeting the response was replied to in."""
  meetingId: String!
  """The response that was replied to."""
  response: TeamPromptResponse!
  """The meeting the response was replied to in."""
  meeting: TeamPromptMeeting!
  """The id of the reply comment"""
  commentId: ID!
  """The reply comment"""
  comment: Comment!
}

"""A notification sent when a task is assigned to or mentions the viewer"""
type NotifyTaskInvolves implements Notification & TeamNotification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The ID of the user who should see this notification"""
  userId: ID!
  """How the user is affiliated with the task"""
  involvement: TaskInvolvementType!
  """The taskId that now involves the userId"""
  taskId: ID!
  """The task that now involves the userId"""
  task: Task
  """The teamMemberId of the person that made the change"""
  changeAuthorId: ID
  """The TeamMember of the person that made the change"""
  changeAuthor: TeamMember!
  """The team this task belongs to"""
  teamId: ID!
  """The team the task is on"""
  team: Team!
}

"""
A notification alerting the user that a team they were on is now archived
"""
type NotifyTeamArchived implements Notification {
  """
  the user that archived the team, can be null if the team was archived via SCIM
  """
  archivor: User
  """The team that was archived"""
  team: Team!
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The ID of the user who should see this notification"""
  userId: ID!
}

"""
A notification sent when an organization exceeds its team limit and becomes locked
"""
type NotifyTeamsLimitExceeded implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The userId that should see this notification"""
  userId: ID!
  """Organization id"""
  orgId: ID!
  """Organization name"""
  orgName: String!
  """Organization picture"""
  orgPicture: URL
}

"""
A notification sent as a reminder that an organization is approaching its team limit
"""
type NotifyTeamsLimitReminder implements Notification {
  """A shortid for the notification"""
  id: ID!
  """
  UNREAD if new, READ if viewer has seen it, CLICKED if viewed clicked it
  """
  status: NotificationStatusEnum!
  """The datetime to activate the notification & send it to the client"""
  createdAt: DateTime!
  type: NotificationEnum!
  """The userId that should see this notification"""
  userId: ID!
  """Organization id"""
  orgId: ID!
  """Organization name"""
  orgName: String!
  """Organization picture"""
  orgPicture: URL
  """Scheduled blocking time at the time of notification"""
  scheduledLockAt: DateTime!
}

"""
An OAuth 2.0 application registered with an organization, allowing third-party apps to access Parabol on behalf of users
"""
type OAuthAPIProvider {
  """The unique provider ID"""
  id: ID!
  """The human-readable application name"""
  name: String!
  """The OAuth 2.0 client ID issued to the application"""
  clientId: String!
  """The allowed redirect URIs for the OAuth flow"""
  redirectUris: [RedirectURI!]!
  """The OAuth scopes granted to this application"""
  scopes: [String!]!
  """When the provider configuration was last updated"""
  updatedAt: DateTime!
}

"""
The OAuth 2.0 client credentials for an application registered with Parabol
"""
type OAuthCredentials {
  """The OAuth 2.0 client ID"""
  clientId: String!
  """The OAuth 2.0 client secret"""
  clientSecret: String!
}

"""
OAuth 2.0 permission scopes that control what data a third-party application can access
"""
enum OAuthScopeEnum {
  """Read meeting data"""
  MEETINGS_READ
  """Create and update meetings"""
  MEETINGS_WRITE
  """Read team data"""
  TEAMS_READ
  """Create and update teams"""
  TEAMS_WRITE
  """Read task data"""
  TASKS_READ
  """Create and update tasks"""
  TASKS_WRITE
  """Read user data"""
  USERS_READ
  """Update user data"""
  USERS_WRITE
  """Read organization data"""
  ORGS_READ
  """Update organization data"""
  ORGS_WRITE
  """Read meeting template data"""
  TEMPLATES_READ
  """Create and update meeting templates"""
  TEMPLATES_WRITE
  """Read page (document) data"""
  PAGES_READ
  """Create and update pages"""
  PAGES_WRITE
  """Read comment data"""
  COMMENTS_READ
  """Create and update comments"""
  COMMENTS_WRITE
}

"""Custom integration providers for this organization"""
type OrgIntegrationProviders {
  """Composite key derived from the org ID"""
  id: ID!
  """Organization specific GitLab integrations"""
  gitlab: [IntegrationProviderOAuth2!]!
}

"""A count of active and inactive users within an organization"""
type OrgUserCount {
  """The number of orgUsers who have an inactive flag"""
  inactiveUserCount: Int!
  """The number of orgUsers who do not have an inactive flag"""
  activeUserCount: Int!
}

"""The role of the org user"""
enum OrgUserRole {
  BILLING_LEADER
  ORG_ADMIN
}

"""An organization"""
type Organization implements OrganizationPartial {
  """The unique organization ID"""
  id: ID!
  """
  The top level domain this organization is linked to, null if only generic emails used
  """
  activeDomain: String
  """
  false if the activeDomain is null or was set automatically via a heuristic, true if set manually
  """
  isActiveDomainTouched: Boolean!
  """The datetime the organization was created"""
  createdAt: DateTime!
  """The safe credit card details"""
  creditCard: CreditCard
  """true if the viewer is the billing leader for the org"""
  isBillingLeader: Boolean!
  """true if the viewer holds the the org admin role on the org"""
  isOrgAdmin: Boolean!
  """The name of the organization"""
  name: String!
  """
  Number of teams with 3+ meetings (>1 attendee) that met within last 30 days
  """
  activeTeamCount: Int!
  """
  Teams in the organization that the viewer has access to.
  For org admins/super users: all teams in the org (viewer's teams first).
  For regular users: teams the viewer is on plus public teams.
  """
  teams: [Team!]! @scope(name: TEAMS_READ)
  """The count of all teams in the organization"""
  allTeamsCount: Int!
  """The datetime the current billing cycle ends"""
  periodEnd: DateTime
  """The datetime the current billing cycle starts"""
  periodStart: DateTime
  """
  Flag the organization as exceeding the tariff limits by setting a datetime
  """
  tierLimitExceededAt: DateTime
  """Schedule the organization to be locked at"""
  scheduledLockAt: DateTime
  """Organization locked at"""
  lockedAt: DateTime
  """The total number of retroMeetings given to the team"""
  retroMeetingsOffered: Int! @deprecated(reason: "Unlimited retros for all!")
  """Number of retro meetings that can be run (if not pro)"""
  retroMeetingsRemaining: Int! @deprecated(reason: "Unlimited retros for all!")
  """The customerId from stripe"""
  stripeId: ID
  """The subscriptionId from stripe"""
  stripeSubscriptionId: ID
  """The last upcoming invoice email that was sent, null if never sent"""
  upcomingInvoiceEmailSentAt: DateTime
  """The datetime the organization was last updated"""
  updatedAt: DateTime
  """The OrganizationUser of the viewer"""
  viewerOrganizationUser: OrganizationUser
  """The users that are part of the organization"""
  organizationUsers(after: String, first: Int): OrganizationUserConnection! @scope(name: USERS_READ)
  """The count of active & inactive users"""
  orgUserCount: OrgUserCount!
  """The leaders of the org"""
  billingLeaders: [OrganizationUser!]! @scope(name: USERS_READ)
  """The assumed company this organization belongs to"""
  company: Company
  """
  Basic meeting metadata for aggregated stats across the entire organization.
  Includes metadata on teams the viewer is not part of
  """
  meetingStats: [MeetingStat!]! @scope(name: MEETINGS_READ)
  """The org avatar"""
  picture: URL
  """The current subscription tier of the organization"""
  tier: TierEnum!
  """Whether the org has access to AI features"""
  useAI: Boolean!
  """
  The tier used for billing purposes (may differ from tier during trials or grace periods)
  """
  billingTier: TierEnum!
  """
  false if the Organization was explicitly marked as not paid manually or by stripe
  """
  isPaid: Boolean!
  """Message to show if the organization is unpaid"""
  unpaidMessageHTML: String
  """When the trial started, iff there is a trial active"""
  trialStartDate: DateTime
  """
  A discount coupon assigned to this organization, to be applied automatically on upgrade
  """
  coupon: OrganizationDiscount
  """Minimal details about all teams in the organization"""
  teamStats: [TeamStat!]! @scope(name: TEAMS_READ)
  """Whether the org has a feature flag enabled or not"""
  featureFlag(featureName: String!): Boolean!
  """The SAML record attached to the Organization, if any"""
  saml: SAML
  """
  The SAML id for the organization if it is provisioned via SAML attribute
  """
  samlId: ID
  """
  A list of domains approved by the organization to join.
  Empty if all domains are allowed
  """
  approvedDomains: [String!]!
  """Custom integration providers with organization scope"""
  integrationProviders: OrgIntegrationProviders!
  """OAuth 2.0 Applications registered for this organization"""
  oauthApplications: [OAuthAPIProvider!]!
  """Get an OAuth 2.0 Application by ID"""
  oauthAPIProvider(providerId: ID!): OAuthAPIProvider
  """The feature flags the org has enabled"""
  orgFeatureFlags: [OwnedFeatureFlag!]!
}

"""A discount coupon assigned to an organization to be applied on upgrade"""
type OrganizationDiscount {
  """Percentage off the subscription price (e.g. 50 for 50% off)"""
  percentOff: Float!
  """Number of months the discount applies. Null means it lasts forever."""
  durationInMonths: Int
}

"""
Minimal organization fields shared by Organization and OrganizationPreview
"""
interface OrganizationPartial {
  """The unique organization ID"""
  id: ID!
  """The name of the organization"""
  name: String!
  """The organization avatar URL"""
  picture: URL
}

"""
A lightweight organization summary for use in access control and notification contexts
"""
type OrganizationPreview implements OrganizationPartial {
  """The unique organization ID"""
  id: ID!
  """The name of the organization"""
  name: String!
  """The organization avatar URL"""
  picture: URL
}

"""
A discriminated union of all possible organization subscription event payloads
"""
type OrganizationSubscriptionPayload {
  fieldName: String!
  AddIntegrationProviderSuccess: AddIntegrationProviderSuccess
  ArchiveOrganizationPayload: ArchiveOrganizationPayload
  DowngradeToStarterPayload: DowngradeToStarterPayload
  RemoveIntegrationProviderSuccess: RemoveIntegrationProviderSuccess
  RemoveOrgUsersSuccess: RemoveOrgUsersSuccess
  ToggleAIFeaturesSuccess: ToggleAIFeaturesSuccess
  SetOrgUserRoleSuccess: SetOrgUserRoleSuccess
  UpdateCreditCardPayload: UpdateCreditCardPayload
  UpdateIntegrationProviderSuccess: UpdateIntegrationProviderSuccess
  UpdateOrgPayload: UpdateOrgPayload
  UpdateTemplateScopeSuccess: UpdateTemplateScopeSuccess
  UpgradeToTeamTierSuccess: UpgradeToTeamTierSuccess
  UpdateOAuthAPIProviderPayload: UpdateOAuthAPIProviderPayload
}

"""organization-specific details about a user"""
type OrganizationUser {
  """Composite key: orgId::userId"""
  id: ID!
  """the datetime the user first joined the org"""
  joinedAt: DateTime!
  """The organization this record belongs to"""
  orgId: ID!
  """The user attached to the organization"""
  organization: Organization!
  """if not a member, the datetime the user was removed from the org"""
  removedAt: DateTime
  """role of the user in the org"""
  role: OrgUserRole
  """The user this record belongs to"""
  userId: ID!
  """The user attached to the organization"""
  user: User!
  """The suggested tier upgrade for this user based on usage"""
  suggestedTier: TierEnum
  """The effective tier for this user within the organization"""
  tier: TierEnum
  """The tier used for billing this user"""
  billingTier: TierEnum
}

"""A connection to a list of items."""
type OrganizationUserConnection {
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """A list of edges."""
  edges: [OrganizationUserEdge!]!
}

"""An edge in a connection."""
type OrganizationUserEdge {
  """The item at the end of the edge"""
  node: OrganizationUser!
  """A cursor for use in pagination"""
  cursor: String!
}

"""
A feature flag with its enabled status for a specific owner (user, team, or organization)
"""
type OwnedFeatureFlag {
  """The ID of the feature flag"""
  id: ID!
  """The name of the feature flag"""
  featureName: String!
  """Description of the feature flag"""
  description: String
  """Expiration date of the feature flag"""
  expiresAt: DateTime!
  """The scope of the feature flag"""
  scope: FeatureFlagScope!
  """Whether the flag is enabled for an owner or not"""
  enabled: Boolean
}

"""
A collaborative document page that can be nested, shared, and linked to teams or meetings
"""
type Page implements PagePartial {
  """The unique page ID"""
  id: ID!
  """The ID of the user who owns this page"""
  userId: ID!
  """The page title, null if untitled"""
  title: String
  """When the page was created"""
  createdAt: DateTime!
  """When the page was last updated"""
  updatedAt: DateTime!
  """Access control settings for this page"""
  access: PageAccess!
  """The ID of the parent page, null if this is a root page"""
  parentPageId: ID
  """The ID of the team this page belongs to, null if it is private"""
  teamId: ID
  """The parent page, null if this is a root page"""
  parentPage: PagePartial
  """The team this page belongs to, null if it is private"""
  team: Team @scope(name: TEAMS_READ)
  """true if this page is nested under a parent that links back to it"""
  isParentLinked: Boolean!
  """true if this page is only visible to the owner"""
  isPrivate: Boolean!
  """true if this page functions as a database view"""
  isDatabase: Boolean!
  """
  The sort order of this page among its siblings, as a fractional index string
  """
  sortOrder: String!
  """The viewer-specific sort order override, as a fractional index string"""
  userSortOrder: String!
  """When the page was deleted, null if not deleted"""
  deletedAt: DateTime
  """The ID of the user who deleted this page, null if not deleted"""
  deletedBy: ID
  """The user who deleted this page, null if not deleted"""
  deletedByUser: User
  """IDs of all ancestor pages from root to direct parent"""
  ancestorIds: [ID!]!
  """All ancestor pages from root to direct parent"""
  ancestors: [PagePartial!]!
  """true if this page serves as a table of contents for a meeting"""
  isMeetingTOC: Boolean!
}

"""
The access control configuration for a page, listing who can view or edit it
"""
type PageAccess {
  """
  The viewer's access role on this page, null if the viewer has no access
  """
  viewer: PageRoleEnum
  """The public access role for this page, null if not publicly accessible"""
  public: PageRoleEnum
  """Guest users (by email) who have been granted access"""
  guests: [PageAccessGuest!]!
  """Individual users who have been granted explicit access"""
  users: [PageAccessUser!]!
  """Teams that have been granted access"""
  teams: [PageAccessTeam!]!
  """Organizations that have been granted access"""
  organizations: [PageAccessOrganization!]!
  """
  Users who have requested access to this page within the last 30 days but have not yet been granted access.
  """
  pendingRequests: [PageAccessRequest!]!
}

"""A guest user identified by email who has been granted access to a page"""
type PageAccessGuest {
  """The email address of the guest"""
  email: Email!
  """The access role granted to this guest"""
  role: PageRoleEnum!
}

"""An organization that has been granted access to a page"""
type PageAccessOrganization {
  """The organization that was granted access"""
  organization: OrganizationPreview!
  """The access role granted to all members of the organization"""
  role: PageRoleEnum!
}

"""A pending request from a user who wants access to a page"""
type PageAccessRequest {
  """The user who requested access"""
  user: UserPreview!
  """The access role the user is requesting"""
  role: PageRoleEnum!
  """An optional message from the requester explaining why they need access"""
  reason: String
  """When the access request was submitted"""
  createdAt: DateTime!
}

"""A team that has been granted access to a page"""
type PageAccessTeam {
  """The team that was granted access"""
  team: TeamPreview!
  """The access role granted to all members of the team"""
  role: PageRoleEnum!
}

"""A specific user who has been granted explicit access to a page"""
type PageAccessUser {
  """The user who was granted access"""
  user: UserPreview!
  """The access role granted to this user"""
  role: PageRoleEnum!
}

"""A connection of Pages"""
type PageConnection {
  """Page info with cursors as strings"""
  pageInfo: PageInfo!
  """A list of edges."""
  edges: [PageEdge!]!
}

"""The format of the content string provided to editPageContent"""
enum PageContentFormatEnum {
  markdown
  json
}

"""An edge in a connection."""
type PageEdge {
  """The item at the end of the edge"""
  node: Page!
  cursor: String!
}

"""Information about pagination in a connection."""
type PageInfo {
  """When paginating forwards, are there more items?"""
  hasNextPage: Boolean!
  """When paginating backwards, are there more items?"""
  hasPreviousPage: Boolean!
  """When paginating backwards, the cursor to continue."""
  startCursor: String
  """When paginating forwards, the cursor to continue."""
  endCursor: String
}

"""Information about pagination in a connection."""
type PageInfoDateCursor {
  """When paginating forwards, are there more items?"""
  hasNextPage: Boolean!
  """When paginating backwards, are there more items?"""
  hasPreviousPage: Boolean!
  """When paginating backwards, the cursor to continue."""
  startCursor: DateTime
  """When paginating forwards, the cursor to continue."""
  endCursor: DateTime
}

"""
Minimal page fields shared by Page, PagePreview, and other lightweight page representations
"""
interface PagePartial {
  """The unique page ID"""
  id: ID!
  """The page title, null if untitled"""
  title: String
  """The ID of the team this page belongs to, null if private"""
  teamId: ID
  """The team this page belongs to, null if private"""
  team: TeamPartial
}

"""
A lightweight page summary for use in notification and access control contexts
"""
type PagePreview implements PagePartial {
  """The unique page ID"""
  id: ID!
  """The page title, null if untitled"""
  title: String
  """The ID of the team this page belongs to, null if private"""
  teamId: ID
  """The team this page belongs to, null if private"""
  team: TeamPartial
}

"""The level of access a user, team, or organization has on a page"""
enum PageRoleEnum {
  """Full control including sharing, deleting, and managing access"""
  owner
  """Can edit page content"""
  editor
  """Can read content and add comments"""
  commenter
  """Can read content only"""
  viewer
}

"""The section that a page lives in for a viewer"""
enum PageSectionEnum {
  private
  shared
  team
  page
}

"""The subject or owner associated with a page"""
enum PageSubjectEnum {
  external
  user
  team
  organization
}

"""Result of parsing SAML identity provider metadata XML"""
union ParseSAMLMetadataPayload = ErrorPayload | ParseSAMLMetadataSuccess

"""
Successfully parsed SAML metadata, containing the identity provider URL
"""
type ParseSAMLMetadataSuccess {
  """The SAML identity provider SSO URL extracted from the metadata"""
  url: String!
}

"""Result of saving a GitHub search query for later reuse"""
union PersistGitHubSearchQueryPayload = ErrorPayload | PersistGitHubSearchQuerySuccess

type PersistGitHubSearchQuerySuccess {
  """The affected teamId"""
  teamId: ID!
  """The affected userId"""
  userId: ID!
  """The auth with the updated search queries"""
  githubIntegration: GitHubIntegration!
}

"""Result of saving an integration search query for later reuse"""
union PersistIntegrationSearchQueryPayload = PersistIntegrationSearchQuerySuccess | ErrorPayload

"""Successfully saved an integration search query"""
type PersistIntegrationSearchQuerySuccess {
  """The user whose search query was saved"""
  userId: ID
  """The team context for the saved search query"""
  teamId: ID
  """The updated Jira Server integration with the saved query"""
  jiraServerIntegration: JiraServerIntegration
}

"""Result of saving a Jira search query for later reuse"""
union PersistJiraSearchQueryPayload = ErrorPayload | PersistJiraSearchQuerySuccess

type PersistJiraSearchQuerySuccess {
  """The newly created auth"""
  atlassianIntegration: AtlassianIntegration
}

"""
An API token belonging to a user for programmatic access, with optional scope restrictions
"""
type PersonalAccessToken {
  id: ID!
  """Human-readable label for the token"""
  name: String!
  """
  The first few characters of the token used to identify it without exposing the full secret
  """
  prefix: String!
  """The OAuth permission scopes granted to this token"""
  scopes: [OAuthScopeEnum!]!
  """Null means the token can access all orgs the user belongs to"""
  grantedOrgIds: [ID!]
  """Null means the token can access all teams the user belongs to"""
  grantedTeamIds: [ID!]
  """Null means the token can access all pages the user can access"""
  grantedPageIds: [ID!]
  createdAt: DateTime!
  """The last time this token was used to make an API request"""
  lastUsedAt: DateTime
  """When the token expires; null means it never expires"""
  expiresAt: DateTime
  """When the token was revoked; null means it is still active"""
  revokedAt: DateTime
}

"""
Data produced when a retrospective meeting phase completes; only the relevant phase field is populated
"""
type PhaseCompletePayload {
  """payload provided if the retro reflect phase was completed"""
  reflect: ReflectPhaseCompletePayload
  """payload provided if the retro grouping phase was completed"""
  group: GroupPhaseCompletePayload
  """payload provided if the retro voting phase was completed"""
  vote: VotePhaseCompletePayload
}

"""
Result of a user hovering over or leaving the voting deck in a Poker meeting
"""
union PokerAnnounceDeckHoverPayload = ErrorPayload | PokerAnnounceDeckHoverSuccess

"""
Broadcast data when a participant hovers over or leaves the voting deck in a Poker meeting
"""
type PokerAnnounceDeckHoverSuccess {
  """The Poker meeting where the hover occurred"""
  meetingId: ID!
  """The estimate stage where the hover occurred"""
  stageId: ID!
  """The user who is hovering over the deck"""
  userId: ID!
  user: User!
  """True if the user is currently hovering, false if they left"""
  isHover: Boolean!
  """The stage that holds the updated scores"""
  stage: EstimateStage!
}

"""A Poker meeting"""
type PokerMeeting implements NewMeeting {
  """
  The viewer's most recently generated AI inspiration items for a given integration service,
  cached for a short window. Empty if none have been generated recently.
  """
  inspirationItems(service: ServiceEnum!): [InspirationItem!]!
  """The number of comments generated in the meeting"""
  commentCount: Int!
  """The team members that were active during the time of the meeting"""
  meetingMembers: [PokerMeetingMember!]!
  """The number of stories scored during a meeting"""
  storyCount: Int!
  """A single story created in a Sprint Poker meeting"""
  story(storyId: ID!): Task
  teamId: ID!
  """
  The ID of the template used for the meeting. Note the underlying template could have changed!
  """
  templateId: ID! @deprecated(reason: "The underlying template could be mutated. Use templateRefId")
  """The ID of the immutable templateRef used for the meeting"""
  templateRefId: ID!
  """The Poker meeting member of the viewer"""
  viewerMeetingMember: PokerMeetingMember
  """The unique meeting id. shortid."""
  id: ID!
  """The timestamp the meeting was created"""
  createdAt: DateTime!
  """
  The id of the user that created the meeting, null if user was hard deleted
  """
  createdBy: ID
  """The user that created the meeting, null if user was hard deleted"""
  createdByUser: User
  """The timestamp the meeting officially ended"""
  endedAt: DateTime
  """The location of the facilitator in the meeting"""
  facilitatorStageId: ID!
  """The userId (or anonymousId) of the most recent facilitator"""
  facilitatorUserId: ID!
  """The facilitator team member"""
  facilitator: TeamMember!
  """Is this locked for starter plans?"""
  locked: Boolean!
  """The auto-incrementing meeting number for the team"""
  meetingNumber: Int!
  """The id of the meeting series this meeting belongs to"""
  meetingSeriesId: ID
  """
  The meeting series this meeting is associated with if the meeting is recurring
  """
  meetingSeries: MeetingSeries
  meetingType: MeetingTypeEnum!
  """The name of the meeting"""
  name: String!
  """The organization this meeting belongs to"""
  organization: Organization!
  """
  The phases the meeting will go through, including all phase-specific state
  """
  phases: [NewMeetingPhase!]!
  """
  If meeting has a meeting series associated, this is the time the meeting will end
  """
  scheduledEndTime: DateTime
  """
  The OpenAI generated summary of all the content in the meeting, such as reflections, tasks, and comments. Undefined if the user doesnt have access to the feature or it's unavailable in this meeting type`
  """
  summary: String
  """The time the meeting summary was emailed to the team"""
  summarySentAt: DateTime
  """The team that ran the meeting"""
  team: Team!
  """The last time a meeting was updated (stage completed, finished, etc)"""
  updatedAt: DateTime
  summaryPageId: ID
}

"""All the meeting specifics for a user in a poker meeting"""
type PokerMeetingMember implements MeetingMember {
  """A composite of userId::meetingId"""
  id: ID!
  """true if present, false if absent, else null"""
  isCheckedIn: Boolean @deprecated(reason: "Members are checked in when they enter the meeting now & not created beforehand")
  meetingId: ID!
  meetingType: MeetingTypeEnum!
  teamId: ID!
  teamMember: TeamMember!
  user: User!
  userId: ID!
  """The last time a meeting was updated (stage completed, finished, etc)"""
  updatedAt: DateTime!
  """
  true if the user is not voting and does not want their vote to count towards aggregates
  """
  isSpectating: Boolean!
}

"""The poker-specific meeting settings"""
type PokerMeetingSettings implements TeamMeetingSettings {
  id: ID!
  """The type of meeting these settings apply to"""
  meetingType: MeetingTypeEnum!
  """The broad phase types that will be addressed during the meeting"""
  phaseTypes: [NewMeetingPhaseTypeEnum!]!
  """FK"""
  teamId: ID!
  """The team these settings belong to"""
  team: Team!
  """FK. The template that will be used to start the poker meeting"""
  selectedTemplateId: ID!
  """The template that will be used to start the Poker meeting"""
  selectedTemplate: PokerTemplate!
  """The list of templates used to start a Poker meeting"""
  teamTemplates: [PokerTemplate!]!
  """
  The list of templates shared across the organization to start a Poker meeting
  """
  organizationTemplates(
    first: Int!
    """The cursor, which is the templateId"""
    after: ID
  ): PokerTemplateConnection!
  """
  The list of templates shared across the organization to start a Poker meeting
  """
  publicTemplates(
    first: Int!
    """The cursor, which is the templateId"""
    after: ID
  ): PokerTemplateConnection!
}

"""Result of resetting votes for a Poker dimension so voting can restart"""
union PokerResetDimensionPayload = ErrorPayload | PokerResetDimensionSuccess

"""Successfully reset votes for a Poker dimension"""
type PokerResetDimensionSuccess {
  """The stage that holds the updated isVoting step"""
  stage: EstimateStage!
}

"""Result of revealing all hidden votes in a Poker meeting stage"""
union PokerRevealVotesPayload = ErrorPayload | PokerRevealVotesSuccess

"""Successfully revealed all hidden votes in a Poker meeting stage"""
type PokerRevealVotesSuccess {
  """The stage that holds the updated isVoting step"""
  stage: EstimateStage!
}

"""The team-specific templates for sprint poker meeting"""
type PokerTemplate implements MeetingTemplate {
  """shortid"""
  id: ID!
  createdAt: DateTime!
  """True if template can be used, else false"""
  isActive: Boolean!
  """
  True if template is available to all teams including non-paying teams, else false
  """
  isFree: Boolean!
  """The time of the meeting the template was last used"""
  lastUsedAt: DateTime
  """The name of the template"""
  name: String!
  """
  *Foreign key. The organization that owns the team that created the template
  """
  orgId: ID!
  """Who can see this template"""
  scope: SharingScopeEnum!
  """*Foreign key. The team this template belongs to"""
  teamId: ID!
  """The team this template belongs to"""
  team: Team!
  """The type of the template"""
  type: MeetingTypeEnum!
  updatedAt: DateTime!
  """The dimensions that are part of this template"""
  dimensions: [TemplateDimension!]!
  """A query for the dimension"""
  dimension(
    """The dimension ID for the desired dimension"""
    dimensionId: ID!
  ): TemplateDimension!
  """
  The category this template falls under, e.g. retro, feedback, strategy, etc.
  """
  category: String!
  """
  Whether this template should be in the recommended/quick start sections in the UI.
  """
  isRecommended: Boolean!
  """The url to the illustration used by the template"""
  illustrationUrl: String!
  """The lowest scope of the permissions available to the viewer"""
  viewerLowestScope: SharingScopeEnum!
}

"""A paginated list of Poker meeting templates"""
type PokerTemplateConnection {
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """A list of edges."""
  edges: [PokerTemplateEdge!]!
}

"""Result of updating the description of a Poker template dimension"""
type PokerTemplateDimensionUpdateDescriptionPayload {
  error: StandardMutationError
  dimension: TemplateDimension
}

"""A paginated edge containing a single Poker template"""
type PokerTemplateEdge {
  """The item at the end of the edge"""
  node: PokerTemplate!
  """A cursor for use in pagination"""
  cursor: String!
}

"""A poll created during the meeting"""
type Poll implements Threadable {
  """Poll id in a format of `poll:idGeneratedByDatabase`"""
  id: ID!
  """The timestamp the item was created"""
  createdAt: DateTime!
  """The userId that created the item"""
  createdBy: ID
  """The user that created the item"""
  createdByUser: User!
  """the replies to this threadable item"""
  replies: [Threadable!]!
  """
  The FK of the discussion this task was created in. Null if task was not created in a discussion
  """
  discussionId: ID
  """the parent, if this threadable is a reply, else null"""
  threadParentId: ID
  """the order of this threadable, relative to threadParentId"""
  threadSortOrder: Int
  """The timestamp the item was updated"""
  updatedAt: DateTime!
  """The foreign key for the meeting the poll was created in"""
  meetingId: ID
  """The id of the team (indexed)"""
  teamId: ID!
  """The team this poll belongs to"""
  team: Team!
  """Poll title"""
  title: String!
  """A list of all the poll options related to this poll"""
  options: [PollOption!]!
}

"""Poll options for a given poll"""
type PollOption {
  """Poll option id in a format of `pollOption:idGeneratedByDatabase`"""
  id: ID!
  """The timestamp the item was created"""
  createdAt: DateTime!
  """The timestamp the item was updated"""
  updatedAt: DateTime!
  """
  The foreign key of the poll this option belongs to in a format of `poll:idGeneratedByDatabase`
  """
  pollId: ID!
  """The poll this option belongs to"""
  poll: Poll!
  """The ids of the users who voted for this option"""
  voteUserIds: [ID!]!
  """Poll option title"""
  title: String!
}

"""Input for creating a poll option"""
input PollOptionInput {
  """Poll option title"""
  title: String!
}

"""
Result of transferring the facilitator role to a new team member during a meeting
"""
type PromoteNewMeetingFacilitatorPayload {
  error: StandardMutationError
  """The meeting in progress"""
  meeting: NewMeeting
  """The stage the new facilitator is now on"""
  facilitatorStage: NewMeetingStage
  """The old meeting facilitator"""
  oldFacilitator: User
}

"""Result of transferring team lead status to another team member"""
type PromoteToTeamLeadPayload {
  error: StandardMutationError
  team: Team
  """The team member who was previously the team lead"""
  oldLeader: TeamMember
  """The team member who is now the team lead"""
  newLeader: TeamMember
}

"""
Root object for objects accessible by the viewer or public.
The access can change based on whether the viewer is logged in or not, so this needs to be a separate for easy cache invalidation.
"""
type PublicRoot {
  id: ID!
  """A single page accessible by the viewer or public"""
  page(pageId: ID!): Page
}

"""Result of pushing a team invitation to a user who is already a member"""
type PushInvitationPayload {
  error: StandardMutationError
  """The user who received the invitation push"""
  user: User
  """The meeting the user is being invited into, if any"""
  meetingId: ID
  team: Team
}

"""Root query type for all read operations"""
type Query {
  """The currently authenticated user"""
  viewer: User! @scope(name: USERS_READ)
  """Look up a team's mass invitation by token"""
  massInvitation(
    """The mass invitation token"""
    token: ID!
  ): MassInvitationPayload! @scope(name: TEAMS_READ)
  """Search for GIFs using Giphy"""
  searchGifs(
    """The search query to send to the service"""
    query: String!
    """The ISO 3166-1 country of the user, default is US"""
    country: String
    """The ISO 639-1 locale of the user, default is en_US"""
    locale: String
    """The first n records to return"""
    first: Int!
    """The pagination cursor, if any"""
    after: String
  ): GifResponseConnection!
  """Verify a team invitation token and return details about the invitation"""
  verifiedInvitation(
    """The invitation token"""
    token: ID!
  ): VerifiedInvitationPayload! @scope(name: TEAMS_READ)
  """Generate an AI-suggested title for a reflection group in the demo"""
  getDemoGroupTitle(
    """The text content of the reflections in the group"""
    reflectionsContent: [String!]!
  ): GetDemoGroupTitlePayload!
  """Look up the SAML identity provider SSO URL for a given email domain"""
  SAMLIdP(
    """the email associated with a SAML login. null if instance is SSO-only"""
    email: ID
    """true if the user was invited, else false"""
    isInvited: Boolean
  ): String
  """
  A root for public access to pages and other public objects which change access based on whether the viewer is logged in or not.
  """
  public: PublicRoot!
}

"""A custom scalar type for representing RRule strings"""
scalar RRule

"""An item that can have reactjis"""
interface Reactable {
  """shortid"""
  id: ID!
  """All the reactjis for the given reflection"""
  reactjis: [Reactji!]!
}

"""The type of reactable"""
enum ReactableEnum {
  COMMENT
  REFLECTION
  RESPONSE
}

"""An aggregate of reactji metadata"""
type Reactji {
  """composite of entity:reactjiId"""
  id: ID!
  """The number of users who have added this reactji"""
  count: Int!
  """The users who added a reactji"""
  users: [User!]!
  """true if the viewer is included in the count, else false"""
  isViewerReactji: Boolean!
}

"""Reason a user provides when downgrading their subscription"""
enum ReasonToDowngradeEnum {
  tooExpensive
  budgetChanges
  missingKeyFeatures
  notUsingPaidFeatures
  anotherTool
}

"""
A valid OAuth redirect URI (HTTPS required, HTTP allowed for localhost only, no fragments)
"""
scalar RedirectURI

"""
The retrospective meeting phase where team members add reflections to prompts
"""
type ReflectPhase implements NewMeetingPhase {
  """shortid"""
  id: ID!
  meetingId: ID!
  teamId: ID!
  """The type of phase"""
  phaseType: NewMeetingPhaseTypeEnum!
  stages: [GenericMeetingStage!]!
  """foreign key. use focusedPrompt"""
  focusedPromptId: ID
  """the Prompt that the facilitator wants the group to focus on"""
  focusedPrompt: ReflectPrompt
  """The prompts used during the reflect phase"""
  reflectPrompts: [ReflectPrompt!]!
}

"""
Data produced when the reflect phase of a retrospective completes, including auto-grouped reflections
"""
type ReflectPhaseCompletePayload {
  """a list of empty reflection groups to remove"""
  emptyReflectionGroupIds: [ID!]!
  """The grouped reflections"""
  reflectionGroups: [RetroReflectionGroup!]!
}

"""
A team-specific reflection prompt. Usually 3 or 4 exist per team, eg Good/Bad/Change, 4Ls, etc.
"""
type ReflectPrompt {
  """shortid"""
  id: ID!
  createdAt: DateTime!
  """foreign key. use the team field"""
  teamId: ID!
  """The team that owns this reflectPrompt"""
  team: Team
  updatedAt: DateTime!
  """the order of the items in the template"""
  sortOrder: String!
  """FK for template"""
  templateId: ID!
  """The template that this prompt belongs to"""
  template: ReflectTemplate!
  """
  The question to answer during the phase of the retrospective (eg What went well?)
  """
  question: String!
  """
  The description to the question for further context. A long version of the question.
  """
  description: String!
  """The color used to visually group a phase item."""
  groupColor: String!
  """
  The datetime that the prompt was removed. Null if it has not been removed.
  """
  removedAt: DateTime
}

"""The team-specific templates for the reflection prompts"""
type ReflectTemplate implements MeetingTemplate {
  """shortid"""
  id: ID!
  createdAt: DateTime!
  """True if template can be used, else false"""
  isActive: Boolean!
  """
  True if template is available to all teams including non-paying teams, else false
  """
  isFree: Boolean!
  """The time of the meeting the template was last used"""
  lastUsedAt: DateTime
  """The name of the template"""
  name: String!
  """
  *Foreign key. The organization that owns the team that created the template
  """
  orgId: ID!
  """Who can see this template"""
  scope: SharingScopeEnum!
  """*Foreign key. The team this template belongs to"""
  teamId: ID!
  """The team this template belongs to"""
  team: Team!
  """The type of the template"""
  type: MeetingTypeEnum!
  updatedAt: DateTime!
  """The prompts that are part of this template"""
  prompts: [ReflectPrompt!]!
  """
  The category this template falls under, e.g. retro, feedback, strategy, etc.
  """
  category: String!
  """
  Whether this template should be in the recommended/quick start sections in the UI.
  """
  isRecommended: Boolean!
  """The url to the illustration used by the template"""
  illustrationUrl: String!
  """The lowest scope of the permissions available to the viewer"""
  viewerLowestScope: SharingScopeEnum!
  """
  Experimental: sub-categories that this template is in (e.g. "popular", "recentlyUsed", "unused",
  etc.)
  """
  subCategories: [String!]!
}

"""A paginated list of retrospective reflection templates"""
type ReflectTemplateConnection {
  """Information to aid in pagination."""
  pageInfo: PageInfo!
  """A list of edges."""
  edges: [ReflectTemplateEdge!]!
}

"""A paginated edge containing a single retrospective reflection template"""
type ReflectTemplateEdge {
  """The item at the end of the edge"""
  node: ReflectTemplate!
  """A cursor for use in pagination"""
  cursor: String!
}

"""Result of updating the description of a retrospective template prompt"""
type ReflectTemplatePromptUpdateDescriptionPayload {
  error: StandardMutationError
  prompt: ReflectPrompt
}

"""Result of updating the group color of a retrospective template prompt"""
type ReflectTemplatePromptUpdateGroupColorPayload {
  error: StandardMutationError
  prompt: ReflectPrompt
}

type ReflectionEmbeddingSuccess {
  reflection: RetroReflection!
}

"""
sorts for the reflection group. default is sortOrder. sorting by voteCount filters out items without votes.
"""
enum ReflectionGroupSortEnum {
  voteCount
  stageOrder
}

"""Result of regenerating the client secret for an OAuth API provider"""
type RegenerateOAuthAPIProviderSecretPayload {
  clientSecret: String!
  provider: OAuthAPIProvider!
}

"""Info associated with a current drag"""
type RemoteReflectionDrag {
  id: ID!
  """The userId of the person currently dragging the reflection"""
  dragUserId: ID
  """The name of the dragUser"""
  dragUserName: String
  isSpotlight: Boolean
  clientHeight: Float
  clientWidth: Float
  """The primary key of the item being drug"""
  sourceId: ID!
  """The estimated destination of the item being drug"""
  targetId: ID
  """horizontal distance from the top left of the target"""
  targetOffsetX: Float
  """vertical distance from the top left of the target"""
  targetOffsetY: Float
  """the left of the source, relative to the client window"""
  clientX: Float
  """the top of the source, relative to the client window"""
  clientY: Float
}

"""Result of removing an agenda item from a meeting"""
type RemoveAgendaItemPayload {
  error: StandardMutationError
  agendaItem: AgendaItem
  meetingId: ID
  """The meeting with the updated agenda item, if any"""
  meeting: NewMeeting
}

"""
Return value for removeApprovedOrganizationDomains, which could be an error
"""
union RemoveApprovedOrganizationDomainsPayload = ErrorPayload | RemoveApprovedOrganizationDomainsSuccess

"""
Successfully removed one or more approved email domains from an organization
"""
type RemoveApprovedOrganizationDomainsSuccess {
  """The organization with updated restrictions"""
  organization: Organization!
}

"""
Result of disconnecting a user's Atlassian (Jira) integration for a team
"""
type RemoveAtlassianAuthPayload {
  error: StandardMutationError
  """The team the integration was removed from"""
  teamId: ID
  """The team member with the updated auth"""
  teamMember: TeamMember
  """The user with updated atlassianAuth"""
  user: User
}

"""Result of disconnecting a user's GitHub integration for a team"""
type RemoveGitHubAuthPayload {
  error: StandardMutationError
  """The team the integration was removed from"""
  teamId: ID
  """The team member with the updated auth"""
  teamMember: TeamMember
  """The user with updated githubAuth"""
  user: User
}

"""
Result of removing an integration provider configuration from an organization or team
"""
union RemoveIntegrationProviderPayload = ErrorPayload | RemoveIntegrationProviderSuccess

type RemoveIntegrationProviderSuccess {
  """The ID of the integration provider that was removed"""
  providerId: ID!
  """
  The updated set of organization integration providers if there were changes
  """
  orgIntegrationProviders: OrgIntegrationProviders
  """Updated team member integrations if there were changes"""
  teamMemberIntegrations: TeamMemberIntegrations
}

"""Return value for removeIntegrationSearchQuery, which could be an error"""
union RemoveIntegrationSearchQueryPayload = ErrorPayload | RemoveIntegrationSearchQuerySuccess

"""Successfully removed a saved integration search query"""
type RemoveIntegrationSearchQuerySuccess {
  """The user whose search query was removed"""
  userId: ID
  """The team context for the removed search query"""
  teamId: ID
  """The updated Jira Server integration after removing the query"""
  jiraServerIntegration: JiraServerIntegration
}

"""Return value for removeOrgUsers, which could be an error"""
union RemoveOrgUsersPayload = ErrorPayload | RemoveOrgUsersSuccess

type RemoveOrgUsersSuccess {
  """The ids of the users removed from the organization"""
  removedUserIds: [String!]!
  """The ids for the organization members that got removed"""
  removedOrgMemberIds: [String!]!
  """The ids of the team members removed"""
  removedTeamMemberIds: [String!]!
  """Basic info about the organization the users were removed from"""
  affectedOrganizationId: ID!
  """The name of the organization the users were removed from"""
  affectedOrganizationName: String!
  """The ids of the teams the users were removed from"""
  affectedTeamIds: [String!]!
  """The tasks that were archived or reassigned"""
  affectedTasks: [Task!]!
  """The ids for the active meetings that users might have been in"""
  affectedMeetingIds: [String!]!
  """The meetings that got affected by the removal"""
  affectedMeetings: [NewMeeting!]!
  """The notifications for each team the users were kicked out of"""
  kickOutNotifications: [NotifyKickedOut!]!
}

"""Result of removing a scoring dimension from a Poker template"""
type RemovePokerTemplateDimensionPayload {
  error: StandardMutationError
  pokerTemplate: PokerTemplate
  dimension: TemplateDimension
}

"""Result of deleting a Poker meeting template"""
type RemovePokerTemplatePayload {
  error: StandardMutationError
  pokerTemplate: PokerTemplate
  pokerMeetingSettings: PokerMeetingSettings
}

"""Result of archiving a Poker scoring scale"""
type RemovePokerTemplateScalePayload {
  """the scale that was removed"""
  scale: TemplateScale!
  """the team that owned the scale being removed"""
  team: Team!
  """A list of dimensions that were using the archived scale"""
  dimensions: [TemplateDimension!]!
}

"""Result of removing a value from a Poker scoring scale"""
type RemovePokerTemplateScaleValuePayload {
  error: StandardMutationError
  """The updated scale after removing the value"""
  scale: TemplateScale
}

"""Result of deleting a retrospective reflection template"""
type RemoveReflectTemplatePayload {
  error: StandardMutationError
  reflectTemplate: ReflectTemplate
  retroMeetingSettings: RetrospectiveMeetingSettings
}

"""Result of removing a prompt from a retrospective reflection template"""
type RemoveReflectTemplatePromptPayload {
  error: StandardMutationError
  reflectTemplate: ReflectTemplate
  prompt: ReflectPrompt
}

"""
Result of deleting a reflection during the reflect phase of a retrospective
"""
type RemoveReflectionPayload {
  error: StandardMutationError
  """The meeting the reflection was removed from"""
  meeting: NewMeeting
  reflection: RetroReflection
  """The stages that were unlocked by navigating"""
  unlockedStages: [NewMeetingStage!]
}

"""Result of disconnecting a user's Slack integration for a team"""
type RemoveSlackAuthPayload {
  error: StandardMutationError
  """The ID of the authorization removed"""
  authId: ID
  """The team the integration was removed from"""
  teamId: ID
  """The user with updated slackAuth"""
  user: User
}

"""Result of removing a team member's integration authentication"""
union RemoveTeamMemberIntegrationAuthPayload = ErrorPayload | RemoveTeamMemberIntegrationAuthSuccess

type RemoveTeamMemberIntegrationAuthSuccess {
  """The team member with the updated auth"""
  teamMember: TeamMember!
  """The user who updated TeamMemberIntegrationAuth object"""
  user: User!
}

"""
Result of removing a member from a team, including task reassignments and notifications
"""
type RemoveTeamMemberPayload {
  error: StandardMutationError
  """The team member removed"""
  teamMember: TeamMember
  """The team the team member was removed from"""
  team: Team
  """The tasks that got reassigned"""
  updatedTasks: [Task!]
  """The user removed from the team"""
  user: User
  """A notification if you were kicked out by the team leader"""
  kickOutNotification: NotifyKickedOut
}

"""Result of renaming a meeting"""
union RenameMeetingPayload = ErrorPayload | RenameMeetingSuccess

type RenameMeetingSuccess {
  """the renamed meeting"""
  meeting: NewMeeting!
}

"""Result of renaming a meeting template"""
type RenameMeetingTemplatePayload {
  error: StandardMutationError
  meetingTemplate: MeetingTemplate
}

"""Result of renaming a dimension in a Poker template"""
type RenamePokerTemplateDimensionPayload {
  error: StandardMutationError
  dimension: TemplateDimension
}

"""Result of renaming a Poker scoring scale"""
type RenamePokerTemplateScalePayload {
  error: StandardMutationError
  scale: TemplateScale
}

"""Result of renaming a prompt in a retrospective reflection template"""
type RenameReflectTemplatePromptPayload {
  error: StandardMutationError
  prompt: ReflectPrompt
}

"""The suggested repos and projects a user can integrate with"""
interface RepoIntegration {
  id: ID!
  service: IntegrationProviderServiceEnum!
}

"""The details associated with the possible repo and project integrations"""
type RepoIntegrationQueryPayload {
  error: StandardMutationError
  """
  true if the items returned are a subset of all the possible integration, else false (all possible integrations)
  """
  hasMore: Boolean
  """All the integrations that are likely to be integrated"""
  items: [RepoIntegration!]
}

"""
Result of requesting access to a page, containing the page and the section it belongs to
"""
type RequestPageAccessPayload {
  """The page access was requested for"""
  page: Page!
  """The section of the page within the viewer's navigation"""
  pageSection: PageSectionEnum!
}

"""Return value for requestToJoinDomain, which could be an error"""
union RequestToJoinDomainPayload = ErrorPayload | RequestToJoinDomainSuccess

type RequestToJoinDomainSuccess {
  """Was the request created successfully"""
  success: Boolean!
}

"""Result of resetting a user's password"""
type ResetPasswordPayload {
  error: StandardMutationError
  """The ID of the user who reset their password"""
  userId: ID
  """the user that changed their password"""
  user: User
}

"""Return value for resetReflectionGroups, which could be an error"""
union ResetReflectionGroupsPayload = ErrorPayload | ResetReflectionGroupsSuccess

"""
Successfully reset reflection groups to their state before AI autogrouping was applied
"""
type ResetReflectionGroupsSuccess {
  """The retrospective meeting with restored reflection groups"""
  meeting: RetrospectiveMeeting!
}

"""Result of resetting a retrospective meeting back to the grouping stage"""
type ResetRetroMeetingToGroupStagePayload {
  error: StandardMutationError
  meeting: NewMeeting
}

"""The stage where the team discusses a single theme"""
type RetroDiscussStage implements NewMeetingStage & DiscussionThreadStage {
  """stageId, shortid"""
  id: ID!
  """The datetime the stage was completed"""
  endAt: DateTime
  """foreign key. try using meeting"""
  meetingId: ID!
  """The meeting this stage belongs to"""
  meeting: NewMeeting!
  """
  true if the facilitator has completed this stage, else false. Should be boolean(endAt)
  """
  isComplete: Boolean!
  """true if any meeting participant can navigate to this stage"""
  isNavigable: Boolean!
  """true if the facilitator can navigate to this stage"""
  isNavigableByFacilitator: Boolean!
  """The phase this stage belongs to"""
  phase: NewMeetingPhase
  """The type of the phase"""
  phaseType: NewMeetingPhaseTypeEnum
  """The datetime the stage was started"""
  startAt: DateTime
  """Number of times the facilitator has visited this stage"""
  viewCount: Int
  """
  true if a time limit is set, false if end time is set, null if neither is set
  """
  isAsync: Boolean
  """true if the viewer is ready to advance, else false"""
  isViewerReady: Boolean!
  """User ids of those who are ready to advance to the next stage"""
  readyUserIds: [ID!]!
  """
  The datetime the phase is scheduled to be finished, null if no time limit or end time is set
  """
  scheduledEndTime: DateTime
  """
  The suggested ending datetime for a phase to be completed async, null if not enough data to make a suggestion
  """
  suggestedEndTime: DateTime
  """
  The suggested time limit for a phase to be completed together, null if not enough data to make a suggestion
  """
  suggestedTimeLimit: Float
  teamId: ID!
  """
  The number of milliseconds left before the scheduled end time. Useful for unsynced client clocks. null if scheduledEndTime is null
  """
  timeRemaining: Float
  """
  The 0-based position of this stage within its phase, ordered by sortOrder.
  """
  stageIdx: Int!
  """The ID to find the discussion that goes in the stage"""
  discussionId: ID!
  """
  The discussion about the stage or a dummy data when there is no disscussion
  """
  discussion: Discussion!
  """foreign key. use reflectionGroup"""
  reflectionGroupId: ID!
  """the group that is the focal point of the discussion"""
  reflectionGroup: RetroReflectionGroup!
  """The sort order for reprioritizing discussion topics"""
  sortOrder: Float!
}

"""A reflection created during the reflect phase of a retrospective"""
type RetroReflection implements Reactable {
  """shortid"""
  id: ID!
  """All the reactjis for the given reflection"""
  reactjis: [Reactji!]!
  """
  The ID of the group that the autogrouper assigned the reflection. Error rate = Sum(autoId != Id) / autoId.count()
  """
  autoReflectionGroupId: ID
  """The timestamp the meeting was created"""
  createdAt: DateTime
  """
  The userId that created the reflection (or unique Id if not a team member)
  """
  creatorId: ID
  """
  an array of all the socketIds that are currently editing the reflection
  """
  editorIds: [ID!]!
  """True if the reflection was not removed, else false"""
  isActive: Boolean!
  """
  true if the viewer (userId) is the creator of the retro reflection, else false
  """
  isViewerCreator: Boolean!
  """The stringified TipTap JSONContent content"""
  content: String!
  """The foreign key to link a reflection to its meeting"""
  meetingId: ID!
  """The retrospective meeting this reflection was created in"""
  meeting: RetrospectiveMeeting!
  """The plaintext version of content"""
  plaintextContent: String!
  """
  The foreign key to link a reflection to its prompt. Immutable. For sorting, use prompt on the group.
  """
  promptId: ID!
  prompt: ReflectPrompt!
  """The foreign key to link a reflection to its group"""
  reflectionGroupId: ID!
  """The group the reflection belongs to, if any"""
  retroReflectionGroup: RetroReflectionGroup
  """
  The sort order of the reflection in the group (increments starting from 0)
  """
  sortOrder: Float!
  """The team that is running the meeting that contains this reflection"""
  team: Team!
  """
  The timestamp the meeting was updated. Used to determine how long it took to write a reflection
  """
  updatedAt: DateTime
  """
  The user that created the reflection, only visible if anonymity is disabled
  """
  creator: User
  """
  The embedding vector for this reflection. Only populated when the embedder is enabled.
  Used client-side during the group phase to compute similarity between reflections.
  """
  embeddingVector: [Float!]
}

"""A reflection group created during the group phase of a retrospective"""
type RetroReflectionGroup {
  """shortid"""
  id: ID!
  """A list of users currently commenting"""
  commentors: [CommentorDetails!] @deprecated(reason: "Moved to ThreadConnection. Can remove Jun-01-2021")
  """The timestamp the meeting was created"""
  createdAt: DateTime!
  """True if the group has not been removed, else false"""
  isActive: Boolean!
  """The foreign key to link a reflection group to its meeting"""
  meetingId: ID!
  """The retrospective meeting this reflection was created in"""
  meeting: RetrospectiveMeeting!
  prompt: ReflectPrompt!
  """The foreign key to link a reflection group to its prompt. Immutable."""
  promptId: ID!
  reflections: [RetroReflection!]!
  """
  Our auto-suggested title, to be compared to the actual title for analytics
  """
  smartTitle: String
  """The sort order of the reflection group"""
  sortOrder: Float!
  """The team that is running the retro"""
  team: Team
  """The title of the grouping of the retrospective reflections"""
  title: String
  """true if a user wrote the title, else false"""
  titleIsUserDefined: Boolean!
  """The timestamp the meeting was updated at"""
  updatedAt: DateTime
  """
  A list of voterIds (userIds). Not available to team to preserve anonymity
  """
  voterIds: [ID!]!
  """The number of votes this group has received"""
  voteCount: Int!
  """The number of votes the viewer has given this group"""
  viewerVoteCount: Int
}

"""A retrospective meeting"""
type RetrospectiveMeeting implements NewMeeting {
  """
  The viewer's most recently generated AI inspiration items for a given integration service,
  cached for a short window. Empty if none have been generated recently.
  """
  inspirationItems(service: ServiceEnum!): [InspirationItem!]!
  """The unique meeting id. shortid."""
  id: ID!
  """The suggested reflection groups created by OpenAI"""
  autogroupReflectionGroups: [AutogroupReflectionGroup!]
  """The groups that existed before the autogrouping"""
  resetReflectionGroups: [AutogroupReflectionGroup!]
  """The Zoom meeting URL for the meeting"""
  videoMeetingURL: String
  """The transcription of the meeting"""
  transcription: [TranscriptBlock!]
  """The timestamp the meeting was created"""
  createdAt: DateTime!
  """
  The id of the user that created the meeting, null if user was hard deleted
  """
  createdBy: ID
  """The user that created the meeting, null if user was hard deleted"""
  createdByUser: User
  """Disables anonymity of reflections"""
  disableAnonymity: Boolean!
  """The timestamp the meeting officially ended"""
  endedAt: DateTime
  """The location of the facilitator in the meeting"""
  facilitatorStageId: ID!
  """The userId (or anonymousId) of the most recent facilitator"""
  facilitatorUserId: ID!
  """The facilitator team member"""
  facilitator: TeamMember!
  """If the AI generated summary is loading"""
  isLoadingSummary: Boolean!
  """The team members that were active during the time of the meeting"""
  meetingMembers: [RetrospectiveMeetingMember!]!
  """The auto-incrementing meeting number for the team"""
  meetingNumber: Int!
  """The id of the meeting series this meeting belongs to"""
  meetingSeriesId: ID
  """
  The meeting series this meeting is associated with if the meeting is recurring
  """
  meetingSeries: MeetingSeries
  """The previous retrospective in the same meeting series, if any"""
  prevMeeting: RetrospectiveMeeting
  meetingType: MeetingTypeEnum!
  """The name of the meeting"""
  name: String!
  """The organization this meeting belongs to"""
  organization: Organization!
  """
  The phases the meeting will go through, including all phase-specific state
  """
  phases: [NewMeetingPhase!]!
  """
  If meeting has a meeting series associated, this is the time the meeting will end
  """
  scheduledEndTime: DateTime
  """
  The OpenAI generated summary of all the content in the meeting, such as reflections, tasks, and comments. Undefined if the user doesnt have access to the feature or it's unavailable in this meeting type`
  """
  summary: String
  """The time the meeting summary was emailed to the team"""
  summarySentAt: DateTime
  teamId: ID!
  """The team that ran the meeting"""
  team: Team!
  """The last time a meeting was updated (stage completed, finished, etc)"""
  updatedAt: DateTime
  """The retrospective meeting member of the viewer"""
  viewerMeetingMember: RetrospectiveMeetingMember
  """
  the threshold used to achieve the autogroup. Useful for model tuning. Serves as a flag if autogroup was used.
  """
  autoGroupThreshold: Float
  """The number of comments generated in the meeting"""
  commentCount: Int!
  """Is this locked for starter plans?"""
  locked: Boolean!
  """
  the number of votes allowed for each participant to cast on a single group
  """
  maxVotesPerGroup: Int!
  """
  the next smallest distance threshold to guarantee at least 1 more grouping will be achieved
  """
  nextAutoGroupThreshold: Float
  """The number of reflections generated in the meeting"""
  reflectionCount: Int!
  """a single reflection group"""
  reflectionGroup(reflectionGroupId: ID!): RetroReflectionGroup
  """The grouped reflections"""
  reflectionGroups(sortBy: ReflectionGroupSortEnum): [RetroReflectionGroup!]!
  """The number of tasks generated in the meeting"""
  taskCount: Int!
  """The tasks created within the meeting"""
  tasks: [Task!]!
  """The ID of the template used for the meeting"""
  templateId: ID!
  """The number of topics generated in the meeting"""
  topicCount: Int!
  """the total number of votes allowed for each participant"""
  totalVotes: Int!
  """
  The sum total of the votes remaining for the meeting members that are present in the meeting
  """
  votesRemaining: Int!
  summaryPageId: ID
}

"""All the meeting specifics for a user in a retro meeting"""
type RetrospectiveMeetingMember implements MeetingMember {
  """A composite of userId::meetingId"""
  id: ID!
  """true if present, false if absent, else null"""
  isCheckedIn: Boolean @deprecated(reason: "Members are checked in when they enter the meeting now & not created beforehand")
  meetingId: ID!
  meetingType: MeetingTypeEnum!
  teamId: ID!
  teamMember: TeamMember!
  user: User!
  userId: ID!
  """The last time a meeting was updated (stage completed, finished, etc)"""
  updatedAt: DateTime!
  """The tasks assigned to members during the meeting"""
  tasks: [Task!]!
  """The number of votes this member has left to cast in the voting phase"""
  votesRemaining: Int!
}

"""The retro-specific meeting settings"""
type RetrospectiveMeetingSettings implements TeamMeetingSettings {
  id: ID!
  """The type of meeting these settings apply to"""
  meetingType: MeetingTypeEnum!
  """The broad phase types that will be addressed during the meeting"""
  phaseTypes: [NewMeetingPhaseTypeEnum!]!
  """FK"""
  teamId: ID!
  """The team these settings belong to"""
  team: Team!
  """
  The total number of votes each team member receives for the voting phase
  """
  totalVotes: Int!
  """
  The maximum number of votes a team member can vote for a single reflection group
  """
  maxVotesPerGroup: Int!
  """Disables anonymity of reflections"""
  disableAnonymity: Boolean!
  """FK. The template that will be used to start the retrospective"""
  selectedTemplateId: ID!
  """The template that will be used to start the retrospective"""
  selectedTemplate: ReflectTemplate!
  """The list of templates used to start a retrospective"""
  reflectTemplates: [ReflectTemplate!]!
  """The list of templates used to start a retrospective"""
  teamTemplates: [ReflectTemplate!]!
  """
  The list of templates shared across the organization to start a retrospective
  """
  organizationTemplates(
    first: Int!
    """The cursor, which is the templateId"""
    after: ID
  ): ReflectTemplateConnection!
  """
  The list of templates shared across the organization to start a retrospective
  """
  publicTemplates(
    first: Int!
    """The cursor, which is the templateId"""
    after: ID
  ): ReflectTemplateConnection!
  """
  The meeting URL that we will transcribe; stored in settings until the meeting starts
  """
  videoMeetingURL: String
}

"""Result of revealing hidden votes in a Team Health meeting stage"""
union RevealTeamHealthVotesPayload = ErrorPayload | RevealTeamHealthVotesSuccess

"""Successfully revealed hidden votes in a Team Health meeting stage"""
type RevealTeamHealthVotesSuccess {
  """The Team Health meeting where votes were revealed"""
  meetingId: ID!
  """The stage where votes were revealed"""
  stageId: ID!
  """The updated stage with all votes now visible"""
  stage: TeamHealthStage!
}

"""A SAML Authentication Strategy"""
type SAML {
  """
  The name of the company, used as a slug in signon URLs. Usually the domain without the tld
  """
  id: ID!
  """
  The domains the company has ownership of. Usually one, but large orgs can have many for contractors, etc.
  """
  domains: [String!]!
  """
  The IdP Signon URL typically the HTTP-Post in metadata, including the SAMLRequest param
  """
  url: String
  """
  A verified blob of XML from the IdP describing how to handle authentication
  """
  metadata: String
  """
  An immutable URL used to retrieve the metadata. If metadata is present but URL is unknown it will be `Unknown`
  """
  metadataURL: String
  createdAt: DateTime!
  updatedAt: DateTime!
  """
  The userId that last updated the record. aGhostUser if the original user was deleted
  """
  lastUpdatedBy: ID!
  """
  The user that last updated the record. aGhostUser if the original user was deleted
  """
  lastUpdatedByUser: User!
  """
  The orgId that owns this SAML record and corresponding domain. Null if SAML record is a legacy orphan
  """
  orgId: ID
  """
  The organization that owns this SAML record and corresponding domain. Null if SAML record is a legacy orphan
  """
  organization: Organization
  """
  The full attribute name used to provision users to specific orgs, see also Organization.samlId
  """
  samlOrgAttribute: ID
  """The authentication type."""
  scimAuthenticationType: SCIMAuthenticationTypeEnum
  """The OAuth client ID used for SCIM authentication."""
  scimOAuthClientId: ID
  """The censored OAuth client secret used for SCIM authentication."""
  scimCensoredOAuthClientSecret: ID
  """The censored bearer token used for SCIM authentication."""
  scimCensoredBearerToken: String
}

"""The authentication method used for SCIM provisioning"""
enum SCIMAuthenticationTypeEnum {
  oauthClientCredentials
  bearerToken
}

"""The date field to filter by when searching"""
enum SearchDateTypeEnum {
  createdAt
  updatedAt
}

"""
Relevance scores for a search result, combining vector (semantic) and keyword matching
"""
type SearchMatchScore {
  """
  Reciprocal Rank Fusion of vectorRank and keywordRank; higher is more relevant
  """
  combined: Float!
  """
  Rank of this result in the vector (semantic) search results; null if not in vector results
  """
  vectorRank: Int
  """
  Rank of this result in the keyword search results; null if not in keyword results
  """
  keywordRank: Int
  """Raw vector similarity score"""
  vector: Float!
  """Raw keyword relevance score"""
  keyword: Float!
}

"""A connection of search results"""
type SearchResultConnection {
  """Page info with cursors as strings"""
  pageInfo: PageInfo!
  """A list of edges."""
  edges: [SearchResultEdge!]!
}

"""
A paginated edge containing a single search result with relevance score and text snippets
"""
type SearchResultEdge {
  """The relevance score breakdown for this result"""
  score: SearchMatchScore!
  """
  Short text excerpts from the matched content highlighting why it matched
  """
  snippets: [String!]!
  """The matched item"""
  node: SearchResultItem!
}

"""
A single search result — may be a page, discussion topic, meeting template, or fixed activity
"""
union SearchResultItem = Page | Discussion | ReflectTemplate | PokerTemplate | FixedActivity

"""The category of content to search across"""
enum SearchTypeEnum {
  """A wiki-style page"""
  page
  """A retro or sprint poker meeting template"""
  meetingTemplate
  """A topic from a retrospective discussion"""
  retrospectiveDiscussionTopic
}

"""Return value for selectTemplate mutation"""
type SelectTemplatePayload {
  error: StandardMutationError
  """The updated meeting settings with the newly selected template"""
  meetingSettings: TeamMeetingSettings
}

"""A service that Parabol integrates with for tasks and calendar"""
enum ServiceEnum {
  """Parabol itself"""
  PARABOL
  """GitHub"""
  github
  """Jira Cloud"""
  jira
  """Linear"""
  linear
  """GitLab"""
  gitlab
  """Mattermost"""
  mattermost
  """Jira Server (self-hosted)"""
  jiraServer
  """Google Calendar"""
  gcal
  """Azure DevOps"""
  azureDevOps
}

"""A field that exists on a 3rd party service"""
type ServiceField {
  """The name of the field as provided by the service"""
  name: String!
  """The field type, to be used for validation and analytics"""
  type: String!
}

"""Return object for SetDefaultSlackChannelPayload"""
union SetDefaultSlackChannelPayload = ErrorPayload | SetDefaultSlackChannelSuccess

"""Success result for setDefaultSlackChannel mutation"""
type SetDefaultSlackChannelSuccess {
  """The id of the slack channel that is now the default slack channel"""
  slackChannelId: ID!
  """The team member with the updated slack channel"""
  teamMember: TeamMember!
}

"""Return value for setJiraDisplayFieldIds mutation"""
type SetJiraDisplayFieldIdsPayload {
  """The team with updated Jira display field configuration"""
  team: Team
}

"""Return value for setMeetingMusic, which could be an error"""
union SetMeetingMusicPayload = ErrorPayload | SetMeetingMusicSuccess

"""Success result for setMeetingMusic mutation"""
type SetMeetingMusicSuccess {
  """The meeting whose music setting was updated"""
  meetingId: ID!
  """URL of the audio track, or null if music was disabled"""
  trackSrc: String
  """Whether music is currently playing"""
  isPlaying: Boolean!
}

"""Return value for setMeetingSettings mutation"""
type SetMeetingSettingsPayload {
  error: StandardMutationError
  """The updated meeting settings"""
  settings: TeamMeetingSettings
}

"""Return value for setNotificationStatus mutation"""
type SetNotificationStatusPayload {
  error: StandardMutationError
  """The updated notification"""
  notification: Notification
}

"""Return value for setOrgUserRole, which could be an error"""
union SetOrgUserRolePayload = ErrorPayload | SetOrgUserRoleSuccess

"""Success result for setOrgUserRole mutation"""
type SetOrgUserRoleSuccess {
  """The organization whose member role was changed"""
  organization: Organization!
  """The org member whose role was updated"""
  updatedOrgMember: OrganizationUser!
  """
  Any notifications created as a result of the role change (e.g. billing leader granted)
  """
  notificationsAdded: [Notification!]!
}

"""
Return value for setPhaseFocus mutation — sets which prompt is in focus during a retro
"""
type SetPhaseFocusPayload {
  error: StandardMutationError
  """The retrospective meeting whose focus changed"""
  meeting: RetrospectiveMeeting!
  """The reflect phase with the updated focused prompt"""
  reflectPhase: ReflectPhase!
}

"""Return object for SetPokerSpectatePayload"""
union SetPokerSpectatePayload = ErrorPayload | SetPokerSpectateSuccess

"""Success result for setPokerSpectate mutation"""
type SetPokerSpectateSuccess {
  """The meeting the spectating change applies to"""
  meetingId: ID!
  """The user whose spectating status changed"""
  userId: ID!
  """The meeting member with the updated isSpectating value"""
  meetingMember: PokerMeetingMember!
  """
  The stages that were updated if the viewer voted and then changed to spectating
  """
  updatedStages: [EstimateStage!]!
}

"""Return value for setSlackNotification mutation"""
type SetSlackNotificationPayload {
  error: StandardMutationError
  """The Slack notifications that were created or updated"""
  slackNotifications: [SlackNotification!]
  """The user with updated slack notifications"""
  user: User
}

"""Return value for setStageTimer mutation"""
type SetStageTimerPayload {
  error: StandardMutationError
  """The updated stage"""
  stage: NewMeetingStage
}

"""Return object for SetTaskEstimatePayload"""
union SetTaskEstimatePayload = ErrorPayload | SetTaskEstimateSuccess

"""Success result for setTaskEstimate mutation"""
type SetTaskEstimateSuccess {
  """The task with the updated estimate"""
  task: Task!
  """The stage that holds the updated finalScore, if meetingId was provided"""
  stage: EstimateStage
  """
  The number of Jira exports for this cloudId. 0 for non-Jira integrations.
  """
  exportCount: Int!
}

"""Return object for SetTaskHighlightPayload"""
union SetTaskHighlightPayload = ErrorPayload | SetTaskHighlightSuccess

"""Success result for setTaskHighlight mutation"""
type SetTaskHighlightSuccess {
  """ID of the meeting where the task is highlighted"""
  meetingId: ID!
  """ID of the task whose highlight changed"""
  taskId: ID!
  """The task whose highlight changed"""
  task: Task!
}

"""Return value for setTeamHealthVote mutation"""
union SetTeamHealthVotePayload = ErrorPayload | SetTeamHealthVoteSuccess

"""Success result for setTeamHealthVote mutation"""
type SetTeamHealthVoteSuccess {
  """The meeting the vote was cast in"""
  meetingId: ID!
  """The stage where the vote was recorded"""
  stageId: ID!
  """The updated team health stage with the new vote"""
  stage: TeamHealthStage!
}

"""Return for setTeamNotificationSetting mutation"""
union SetTeamNotificationSettingPayload = ErrorPayload | SetTeamNotificationSettingSuccess

"""Success result for setTeamNotificationSetting mutation"""
type SetTeamNotificationSettingSuccess {
  """The updated settings"""
  teamNotificationSettings: TeamNotificationSettings!
}

type SetupGoogleDriveWatchSuccess {
  integrations: TeamMemberIntegrations!
}

"""Return value for shareTopic, which could be an error"""
union ShareTopicPayload = ErrorPayload | ShareTopicSuccess

"""Success result for shareTopic mutation"""
type ShareTopicSuccess {
  """The meeting containing the shared topic"""
  meeting: NewMeeting
}

"""The scope of a shareable item"""
enum SharingScopeEnum {
  TEAM
  ORGANIZATION
  PUBLIC
}

"""
A team member's Slack OAuth integration, used to post notifications to Slack
"""
type SlackIntegration {
  """Unique identifier"""
  id: ID!
  """
  true if the auth is updated & ready to use for all features, else false
  """
  isActive: Boolean!
  """Parabol's Slack bot user ID"""
  botUserId: ID
  """
  Parabol's Slack bot access token, used as the primary communication channel
  """
  botAccessToken: ID
  """The timestamp the provider was created"""
  createdAt: DateTime!
  """The default channel to assign to new team notifications"""
  defaultTeamChannelId: String!
  """The Slack workspace ID"""
  slackTeamId: ID
  """The Slack workspace name"""
  slackTeamName: String
  """The user's ID within Slack"""
  slackUserId: ID!
  """The user's display name in Slack"""
  slackUserName: String!
  """The Parabol team this integration is linked to"""
  teamId: ID!
  """The timestamp the token was updated at"""
  updatedAt: DateTime!
  """The Parabol user who connected this Slack integration"""
  userId: ID!
  """A list of events and the slack channels they get posted to"""
  notifications: [SlackNotification!]!
}

"""
A mapping of a Slack notification event to the channel it should be posted in
"""
type SlackNotification {
  id: ID!
  """The event that triggers this notification"""
  event: SlackNotificationEventEnum!
  """
  Whether this notification targets the whole team or an individual member
  """
  eventType: SlackNotificationEventTypeEnum!
  """null if no notification is to be sent"""
  channelId: ID
  teamId: ID!
  userId: ID!
}

"""The event that triggers a Slack notification"""
enum SlackNotificationEventEnum {
  """A meeting has started"""
  meetingStart
  """A meeting has ended"""
  meetingEnd
  """A stage's time limit has expired"""
  MEETING_STAGE_TIME_LIMIT_END
  """A stage's time limit has started"""
  MEETING_STAGE_TIME_LIMIT_START
  """A retro topic was shared with the team"""
  TOPIC_SHARED
  """A standup response was submitted"""
  STANDUP_RESPONSE_SUBMITTED
}

"""The type of event for a slack notification"""
enum SlackNotificationEventTypeEnum {
  """notification that concerns the whole team"""
  team
  """notification that concerns a single member on the team"""
  member
}

"""An error returned by a mutation using the legacy error pattern"""
type StandardMutationError {
  """The title of the error"""
  title: String
  """The full error"""
  message: String!
}

"""Return object for StartCheckInPayload"""
union StartCheckInPayload = StartCheckInSuccess | ErrorPayload

"""Success result for startCheckIn mutation"""
type StartCheckInSuccess {
  """The newly started check-in meeting"""
  meeting: ActionMeeting!
  """ID of the newly started meeting"""
  meetingId: ID!
  """The team the meeting was started for"""
  team: Team!
  """True if creating the Google Calendar event failed"""
  hasGcalError: Boolean
}

"""Payload broadcast when a participant begins dragging a reflection card"""
type StartDraggingReflectionPayload {
  error: StandardMutationError
  """
  The proposed start/end of a drag. Subject to race conditions, it is up to the client to decide to accept or ignore
  """
  remoteDrag: RemoteReflectionDrag
  meeting: NewMeeting
  meetingId: ID
  reflection: RetroReflection
  reflectionId: ID
  teamId: ID
}

"""Return object for StartRetrospectivePayload"""
union StartRetrospectivePayload = ErrorPayload | StartRetrospectiveSuccess

"""Success result for startRetrospective mutation"""
type StartRetrospectiveSuccess {
  """
  The newly started retrospective meeting. Null when the operation only scheduled a recurring
  series with no meeting starting now (rrule first occurrence is in the future).
  """
  meeting: RetrospectiveMeeting
  """ID of the newly started meeting"""
  meetingId: ID
  """The recurring meeting series, if one was created"""
  meetingSeries: MeetingSeries
  """The team the meeting was started for"""
  team: Team!
  """True if creating the Google Calendar event failed"""
  hasGcalError: Boolean
}

"""Return object for StartSprintPokerPayload"""
union StartSprintPokerPayload = ErrorPayload | StartSprintPokerSuccess

"""Success result for startSprintPoker mutation"""
type StartSprintPokerSuccess {
  """ID of the newly started sprint poker meeting"""
  meetingId: ID!
  """The newly started sprint poker meeting"""
  meeting: PokerMeeting!
  """The team the meeting was started for"""
  team: Team!
  """ID of the team"""
  teamId: ID!
  """
  True if there was an error creating the Google Calendar event. False if there was no error or no gcalInput was provided.
  """
  hasGcalError: Boolean!
}

"""Return value for startTeamPrompt mutation, which could be an error"""
union StartTeamPromptPayload = StartTeamPromptSuccess | ErrorPayload

type StartTeamPromptSuccess {
  """
  The started meeting. Null when the operation only scheduled a recurring series with no
  meeting starting now (rrule first occurrence is in the future).
  """
  meeting: TeamPromptMeeting
  """The recurring meeting series, if one was created."""
  meetingSeries: MeetingSeries
  """The team that started the meeting"""
  team: Team!
  """
  True if there was an error creating the Google Calendar event. False if there was no error or no gcalInput was provided.
  """
  hasGcalError: Boolean
}

"""Payload for a Stripe payment failure event"""
type StripeFailPaymentPayload {
  error: StandardMutationError
  """The organization whose payment failed"""
  organization: Organization
  """The notification to a billing leader stating the payment was rejected"""
  notification: NotifyPaymentRejected!
}

"""
Real-time subscriptions for live meeting, notification, org, task, and team updates
"""
type Subscription {
  """
  Subscribe to all events in a meeting (reflections, votes, stages, etc.)
  """
  meetingSubscription(meetingId: ID!): MeetingSubscriptionPayload!
  """Subscribe to notifications for the current user"""
  notificationSubscription: NotificationSubscriptionPayload!
  """Subscribe to organization-level changes for the current user"""
  organizationSubscription: OrganizationSubscriptionPayload!
  """Subscribe to task changes visible to the current user"""
  taskSubscription: TaskSubscriptionPayload!
  """Subscribe to team-level changes for teams the current user belongs to"""
  teamSubscription: TeamSubscriptionPayload!
}

"""
An onboarding or engagement action suggested to the viewer based on their activity
"""
interface SuggestedAction {
  """Unique identifier"""
  id: ID!
  """When the suggested action was created"""
  createdAt: DateTime!
  """
  The priority of the suggested action compared to other suggested actions (smaller number is higher priority)
  """
  priority: Float
  """When the suggested action was dismissed or completed, if applicable"""
  removedAt: DateTime
  """The specific type of suggested action"""
  type: SuggestedActionTypeEnum!
  """The user this action is suggested for"""
  userId: ID!
  """The user who can see this suggestion"""
  user: User!
}

"""A suggestion to create a new team"""
type SuggestedActionCreateNewTeam implements SuggestedAction {
  """Unique identifier"""
  id: ID!
  """When the suggested action was created"""
  createdAt: DateTime!
  """
  The priority of the suggested action compared to other suggested actions (smaller number is higher priority)
  """
  priority: Float
  """When the suggested action was dismissed or completed, if applicable"""
  removedAt: DateTime
  """The specific type of suggested action"""
  type: SuggestedActionTypeEnum!
  """The user this action is suggested for"""
  userId: ID!
  """The user who can see this suggestion"""
  user: User!
}

"""A suggestion to invite others to an existing team"""
type SuggestedActionInviteYourTeam implements SuggestedAction {
  """Unique identifier"""
  id: ID!
  """When the suggested action was created"""
  createdAt: DateTime!
  """
  The priority of the suggested action compared to other suggested actions (smaller number is higher priority)
  """
  priority: Float
  """When the suggested action was dismissed or completed, if applicable"""
  removedAt: DateTime
  """The specific type of suggested action"""
  type: SuggestedActionTypeEnum!
  """The user this action is suggested for"""
  userId: ID!
  """The user who can see this suggestion"""
  user: User!
  """The teamId that we suggest you should invite people to"""
  teamId: ID!
  """The team you should invite people to"""
  team: Team!
}

"""A suggestion to try a check-in (action) meeting with your team"""
type SuggestedActionTryActionMeeting implements SuggestedAction {
  """Unique identifier"""
  id: ID!
  """When the suggested action was created"""
  createdAt: DateTime!
  """
  The priority of the suggested action compared to other suggested actions (smaller number is higher priority)
  """
  priority: Float
  """When the suggested action was dismissed or completed, if applicable"""
  removedAt: DateTime
  """The specific type of suggested action"""
  type: SuggestedActionTypeEnum!
  """The user this action is suggested for"""
  userId: ID!
  """The user who can see this suggestion"""
  user: User!
  """The ID of the team to run an action meeting with"""
  teamId: ID!
  """The team you should run an action meeting with"""
  team: Team!
}

"""A suggestion to try a retrospective meeting with your team"""
type SuggestedActionTryRetroMeeting implements SuggestedAction {
  """Unique identifier"""
  id: ID!
  """When the suggested action was created"""
  createdAt: DateTime!
  """
  The priority of the suggested action compared to other suggested actions (smaller number is higher priority)
  """
  priority: Float
  """When the suggested action was dismissed or completed, if applicable"""
  removedAt: DateTime
  """The specific type of suggested action"""
  type: SuggestedActionTypeEnum!
  """The user this action is suggested for"""
  userId: ID!
  """The user who can see this suggestion"""
  user: User!
  """The ID of the team to run a retro with"""
  teamId: ID!
  """The team you should run a retro with"""
  team: Team!
}

"""A suggestion to try the Parabol demo"""
type SuggestedActionTryTheDemo implements SuggestedAction {
  """Unique identifier"""
  id: ID!
  """When the suggested action was created"""
  createdAt: DateTime!
  """
  The priority of the suggested action compared to other suggested actions (smaller number is higher priority)
  """
  priority: Float
  """When the suggested action was dismissed or completed, if applicable"""
  removedAt: DateTime
  """The specific type of suggested action"""
  type: SuggestedActionTypeEnum!
  """The user this action is suggested for"""
  userId: ID!
  """The user who can see this suggestion"""
  user: User!
}

"""The specific type of the suggested action"""
enum SuggestedActionTypeEnum {
  """Invite teammates to your team"""
  inviteYourTeam
  """Try the Parabol demo"""
  tryTheDemo
  """Run a retrospective meeting"""
  tryRetroMeeting
  """Create a new team"""
  createNewTeam
  """Run a check-in (action) meeting"""
  tryActionMeeting
}

"""A long-term task shared across the team, assigned to a single user"""
type Task implements Threadable {
  """Unique identifier"""
  id: ID!
  """The rich text body of the item"""
  content: String!
  """The timestamp the item was created"""
  createdAt: DateTime!
  """The userId that created the item"""
  createdBy: ID!
  """The user that created the item"""
  createdByUser: User!
  """the replies to this threadable item"""
  replies: [Threadable!]!
  """
  The FK of the discussion this task was created in. Null if task was not created in a discussion
  """
  discussionId: ID
  """the parent, if this threadable is a reply, else null"""
  threadParentId: ID
  """the order of this threadable, relative to threadParentId"""
  threadSortOrder: Int
  """The timestamp the item was updated"""
  updatedAt: DateTime!
  """The agenda item that the task was created in, if any"""
  agendaItem: AgendaItem @scope(name: MEETINGS_READ)
  """Type of the integration if there is one"""
  taskService: TaskServiceEnum
  """a user-defined due date"""
  dueDate: DateTime
  """A list of the most recent estimates for the task"""
  estimates: [TaskEstimate!]!
  """
  a list of users currently editing the task (fed by a subscription, so queries return null)
  """
  editors: [TaskEditorDetails!]!
  """The reference to the single source of truth for this task"""
  integration: TaskIntegration
  """A hash of the integrated task"""
  integrationHash: ID
  """The ID of the meeting the task was created in, if any"""
  meetingId: ID
  """The meeting the task was created in, if any."""
  meeting: NewMeeting @scope(name: MEETINGS_READ)
  """
  The discussion this task was created in, if any. For retrospective tasks, this resolves
  the reflection-group discussion via discussionId; use task.discussion.stage to reach the
  RetroDiscussStage with its reflectionGroup and stageIdx.
  """
  discussion: Discussion @scope(name: MEETINGS_READ)
  """The ID of the meeting in which this task was marked as done, if any"""
  doneMeetingId: ID
  """the plain text content of the task"""
  plaintextContent: String!
  """the shared sort order for tasks on the team dash & user dash"""
  sortOrder: Float!
  """The status of the task"""
  status: TaskStatusEnum!
  """The tags associated with the task"""
  tags: [String!]!
  """The id of the team (indexed). Needed for subscribing to archived tasks"""
  teamId: ID!
  """The team this task belongs to"""
  team: Team! @scope(name: TEAMS_READ)
  """The first block of the content"""
  title: String!
  """The ID of the user the task is assigned to. Null if unassigned."""
  userId: ID
  """
  The user the task is assigned to. Null if it is not assigned to anyone.
  """
  user: User @scope(name: USERS_READ)
  """The owner hovers over the task in their solo update of a checkin"""
  isHighlighted(
    """Meeting for which the highlight is checked"""
    meetingId: ID
  ): Boolean!
}

"""A paginated list of tasks"""
type TaskConnection {
  """Page info with cursors coerced to ISO8601 dates"""
  pageInfo: PageInfoDateCursor
  """A list of edges."""
  edges: [TaskEdge!]!
}

"""A cursor-based edge wrapping a single task in a paginated list"""
type TaskEdge {
  """The item at the end of the edge"""
  node: Task!
  cursor: DateTime
}

"""Details about a user currently editing a task in real time"""
type TaskEditorDetails {
  """The userId of the person editing the task"""
  userId: ID!
  """The name of the userId editing the task"""
  preferredName: String!
}

"""An estimate for a Task that was voted on and scored in a poker meeting"""
type TaskEstimate {
  """The ID of the estimate"""
  id: ID!
  """The timestamp the estimate was created"""
  createdAt: DateTime!
  """The source that a change came in through"""
  changeSource: ChangeSourceEnum!
  """The name of the estimate dimension"""
  name: String!
  """The human-readable label for the estimate"""
  label: String!
  """The task this estimate belongs to"""
  taskId: ID!
  """The userId that added the estimate"""
  userId: ID!
  """The meeting where this estimate was set, if any"""
  meetingId: ID
  """The meeting stageId the estimate occurred in, if any"""
  stageId: ID
  """The discussionId where the estimated was discussed"""
  discussionId: ID
  """
  If the task comes from jira, this is the jira field that the estimate refers to
  """
  jiraFieldId: ID
}

"""Input for setting or updating a task estimate in a poker meeting"""
input TaskEstimateInput {
  """The task being estimated"""
  taskId: ID!
  """The new estimate value"""
  value: String!
  """The name of the estimate, e.g. Story Points"""
  dimensionName: String!
  """The poker meeting where the estimate is being set"""
  meetingId: ID!
}

"""
A reference to a task that lives in an external integration (e.g. GitHub, Jira)
"""
interface TaskIntegration {
  id: ID!
}

"""How a user is involved with a task (listed in hierarchical order)"""
enum TaskInvolvementType {
  """The task is assigned to this user"""
  ASSIGNEE
  """The user is mentioned in the task"""
  MENTIONEE
}

"""The external service a task is integrated with"""
enum TaskServiceEnum {
  """GitHub"""
  github
  """Jira Cloud"""
  jira
  """Parabol (no external integration)"""
  PARABOL
  """Jira Server (self-hosted)"""
  jiraServer
  """GitLab"""
  gitlab
  """Azure DevOps"""
  azureDevOps
  """Linear"""
  linear
}

"""The status of a task"""
enum TaskStatusEnum {
  """In progress"""
  active
  """Blocked or needs attention"""
  stuck
  """Completed"""
  done
  """Planned for the future"""
  future
}

"""
Subscription payload for task-related changes visible to the current user
"""
type TaskSubscriptionPayload {
  fieldName: String!
  ChangeTaskTeamPayload: ChangeTaskTeamPayload
  CreateTaskIntegrationPayload: CreateTaskIntegrationPayload
  CreateTaskPayload: CreateTaskPayload
  DeleteTaskPayload: DeleteTaskPayload
  EditTaskPayload: EditTaskPayload
  RemoveOrgUsersSuccess: RemoveOrgUsersSuccess
  RemoveTeamMemberPayload: RemoveTeamMemberPayload
  UpdateTaskPayload: UpdateTaskPayload
  UpdateTaskDueDatePayload: UpdateTaskDueDatePayload
}

interface Node {
  id: ID!
}

"""A team"""
type Team implements Node & TeamPartial {
  """A shortid for the team"""
  id: ID!
  """The datetime the team was created"""
  createdAt: DateTime!
  """The userId that created the team. Non-null at v2.22.0+"""
  createdBy: ID
  """true if the team was created when the account was created, else false"""
  isOnboardTeam: Boolean!
  """The type of the last meeting run"""
  lastMeetingType: MeetingTypeEnum!
  """
  The datetime of the team's most recent meeting (from either active or completed meetings)
  """
  lastMetAt: DateTime
  """
  The hash and expiration for a token that allows anyone with it to join the team
  """
  massInvitation(
    """the meetingId to optionally direct them to"""
    meetingId: ID
  ): MassInvitation!
  """The name of the team"""
  name: String!
  """The organization to which the team belongs"""
  orgId: ID!
  """Arbitrary tags that the team uses"""
  tags: [String]
  """The datetime the team was last updated"""
  updatedAt: DateTime
  """The outstanding invitations to join the team"""
  teamInvitations: [TeamInvitation!]!
  """true if the viewer is the team lead, else false"""
  isViewerLead: Boolean!
  """The team-specific settings for running all available types of meetings"""
  meetingSettings(
    """the type of meeting for the settings"""
    meetingType: MeetingTypeEnum!
  ): TeamMeetingSettings!
  """A query for the scale"""
  scale(
    """The scale ID for the desired scale"""
    scaleId: ID!
  ): TemplateScale @scope(name: TEMPLATES_READ)
  """The list of scales this team can use"""
  scales: [TemplateScale!]! @scope(name: TEMPLATES_READ)
  """
  list of meetings that are currently in progress including active meetings of activeMeetingSeries
  """
  activeMeetings: [NewMeeting!]! @scope(name: MEETINGS_READ)
  """
  list of all active meeting series, a series can be active without having an active meeting
  """
  activeMeetingSeries: [MeetingSeries!]! @scope(name: MEETINGS_READ)
  """Whether the team has a feature flag enabled or not"""
  featureFlag(featureName: String!): Boolean!
  """
  The number of qualifying meetings that have an AI generated summary. Qualifying meetings are meetings with three or more meeting members and five or more reflections
  """
  qualAIMeetingsCount: Int!
  """The new meeting in progress, if any"""
  meeting(
    """The unique meetingId"""
    meetingId: ID!
  ): NewMeeting @scope(name: MEETINGS_READ)
  organization: Organization! @scope(name: ORGS_READ)
  """The agenda items for the upcoming or current meeting"""
  agendaItems: [AgendaItem!]! @scope(name: MEETINGS_READ)
  """All of the tasks for this team"""
  tasks(
    first: Int
    """the datetime cursor"""
    after: DateTime
  ): TaskConnection! @scope(name: TASKS_READ)
  """All the team members actively associated with the team"""
  teamMembers(
    """the field to sort the teamMembers by"""
    sortBy: String
  ): [TeamMember!]!
  """true if the team has been archived"""
  isArchived: Boolean
  """
  Whether or not new users with the same domain and a verified email should auto-join the team
  """
  autoJoin: Boolean!
  """Whether the viewer belongs to the team"""
  isViewerOnTeam: Boolean!
  """true if the viewer is an admin for the team's org, else false"""
  isOrgAdmin: Boolean!
  """The team's current billing tier"""
  tier: TierEnum!
  """
  The tier the team is actively billed at (may differ from tier during trials)
  """
  billingTier: TierEnum!
  """The team member that is the viewer"""
  viewerTeamMember: TeamMember
  """The team member that is the team lead"""
  teamLead: TeamMember!
  """The number of retro meetings the team has had"""
  retroMeetingsCount: Int!
  """
  Whether the team is visible to everyone in the org and anyone can join it without an invitation
  """
  isPublic: Boolean!
  """The viewer-specific sort order index. Present in User.teams"""
  sortOrder: String!
  """The list of Jira fields to be displayed alongside the task content"""
  jiraDisplayFieldIds: [String!]
}

"""The right drawer types available on the team dashboard"""
enum TeamDrawer {
  """The agenda items drawer"""
  agenda
  """The manage team members drawer"""
  manageTeam
}

"""The meeting phase where team members answer health check questions"""
type TeamHealthPhase implements NewMeetingPhase {
  """Unique identifier"""
  id: ID!
  meetingId: ID!
  teamId: ID!
  """The type of phase"""
  phaseType: NewMeetingPhaseTypeEnum!
  stages: [TeamHealthStage!]!
}

"""A single team health question stage where participants vote on a label"""
type TeamHealthStage implements NewMeetingStage {
  """Unique identifier"""
  id: ID!
  """The datetime the stage was completed"""
  endAt: DateTime
  """The ID of the meeting this stage belongs to"""
  meetingId: ID!
  """The meeting this stage belongs to"""
  meeting: NewMeeting!
  """
  true if the facilitator has completed this stage, else false. Should be boolean(endAt)
  """
  isComplete: Boolean!
  """true if any meeting participant can navigate to this stage"""
  isNavigable: Boolean!
  """true if the facilitator can navigate to this stage"""
  isNavigableByFacilitator: Boolean!
  """The phase this stage belongs to"""
  phase: NewMeetingPhase
  """The type of the phase"""
  phaseType: NewMeetingPhaseTypeEnum
  """The datetime the stage was started"""
  startAt: DateTime
  """Number of times the facilitator has visited this stage"""
  viewCount: Int
  """
  true if a time limit is set, false if end time is set, null if neither is set
  """
  isAsync: Boolean
  """true if the viewer is ready to advance, else false"""
  isViewerReady: Boolean!
  """User ids of those who are ready to advance to the next stage"""
  readyUserIds: [ID!]!
  """
  The datetime the phase is scheduled to be finished, null if no time limit or end time is set
  """
  scheduledEndTime: DateTime
  """
  The suggested ending datetime for a phase to be completed async, null if not enough data to make a suggestion
  """
  suggestedEndTime: DateTime
  """
  The suggested time limit for a phase to be completed together, null if not enough data to make a suggestion
  """
  suggestedTimeLimit: Float
  teamId: ID!
  """
  The number of milliseconds left before the scheduled end time. Useful for unsynced client clocks. null if scheduledEndTime is null
  """
  timeRemaining: Float
  """
  The 0-based position of this stage within its phase, ordered by sortOrder.
  """
  stageIdx: Int!
  """Team health question of the stage"""
  question: String!
  """Answer options for the question"""
  labels: [String!]!
  """The label the viewer voted for, if any"""
  viewerVote: String
  """
  Score counts for each label, in the same order as labels. Only available if isRevealed is true
  """
  votes: [Int!]
  """userIds of users who have voted"""
  votedUserIds: [ID!]!
  """Users who have voted"""
  votedUsers: [User!]!
  """True if the votes were revealed, else false"""
  isRevealed: Boolean!
}

"""An invitation to become a team member"""
type TeamInvitation {
  """The unique invitation Id"""
  id: ID!
  """null if not accepted, else the datetime the invitation was accepted"""
  acceptedAt: DateTime
  """null if not accepted, else the userId that accepted the invitation"""
  acceptedBy: ID
  """The datetime the invitation was created"""
  createdAt: DateTime!
  """The email of the invitee"""
  email: Email!
  """The datetime the invitation expires. Changes when team is archived."""
  expiresAt: DateTime!
  """The userId of the person that sent the invitation"""
  invitedBy: ID!
  """The userId of the person that sent the invitation"""
  inviter: User!
  """the meetingId that the invite was generated for"""
  meetingId: ID
  """The team invited to"""
  teamId: ID!
  """48-byte hex encoded random string"""
  token: ID!
}

"""The reason a team invitation could not be accepted"""
enum TeamInvitationErrorEnum {
  """The invitation was already accepted"""
  accepted
  """The invitation has expired"""
  expired
  """No matching invitation was found"""
  notFound
  """The invitee's email domain is not allowed on this team"""
  restrictedDomain
  """The invitee's email address has not been verified"""
  unverifiedEmail
}

"""The response to a teamInvitation query"""
type TeamInvitationPayload {
  """The team invitation, if any"""
  teamInvitation: TeamInvitation
  """the teamId of the team trying to join"""
  teamId: ID
  """one of the active meetings trying to join"""
  meetingId: ID
  """true if the viewer is already on the team"""
  isOnTeam: Boolean
}

"""The team settings for a specific type of meeting"""
interface TeamMeetingSettings {
  id: ID!
  """The type of meeting these settings apply to"""
  meetingType: MeetingTypeEnum!
  """The broad phase types that will be addressed during the meeting"""
  phaseTypes: [NewMeetingPhaseTypeEnum!]!
  """The ID of the team these settings belong to"""
  teamId: ID!
  """The team these settings belong to"""
  team: Team!
}

"""A member of a team"""
type TeamMember {
  """An ID for the teamMember. userId::teamId"""
  id: ID!
  """The datetime the team member was created"""
  createdAt: DateTime!
  """true if the user is a part of the team, false if they no longer are"""
  isNotRemoved: Boolean
  """Is user a team lead?"""
  isLead: Boolean!
  """true if the user prefers to not vote during a poker meeting"""
  isSpectatingPoker: Boolean!
  """
  the type of drawer that is open in the team dash. Null if the drawer is closed
  """
  openDrawer: TeamDrawer
  """true if this team member belongs to the user that queried it"""
  isSelf: Boolean!
  """
  The integrations that the team member has authorized. Only accessible by the team member themselves
  """
  integrations: TeamMemberIntegrations!
  """The meeting specifics for the meeting the team member is currently in"""
  meetingMember(meetingId: ID!): MeetingMember
  """The integrations that the team has previously used"""
  prevUsedRepoIntegrations(
    """the number of repo integrations to return"""
    first: Int!
    after: DateTime
  ): RepoIntegrationQueryPayload!
  """The integrations that the user would probably like to use"""
  repoIntegrations(
    """the number of repo integrations to return"""
    first: Int!
    after: DateTime
    """
    true if we should fetch from the network, false if we should use the cache
    """
    networkOnly: Boolean!
  ): RepoIntegrationQueryPayload!
  """Tasks owned by the team member"""
  tasks(
    first: Int
    """the datetime cursor"""
    after: DateTime
  ): TaskConnection
  """The team this team member belongs to"""
  team: Team
  """The ID of the team this member belongs to"""
  teamId: ID!
  """The user for the team member"""
  user: User!
  """The ID of the Parabol user"""
  userId: ID!
  """All the integrations that the user could possibly use"""
  allAvailableRepoIntegrations: [RepoIntegration!]!
  """Is user an admin of the team's org?"""
  isOrgAdmin: Boolean!
}

"""
Auth credentials linking a team member to an external integration provider
"""
interface TeamMemberIntegrationAuth {
  """The token's unique identifier"""
  id: ID!
  """The team that the token is linked to"""
  teamId: ID!
  """The timestamp the token was created"""
  createdAt: DateTime!
  """The timestamp the token was updated at"""
  updatedAt: DateTime!
  """The ID of the integration provider this token belongs to"""
  providerId: ID!
  """
  The service this token is associated with, denormalized from the provider
  """
  service: IntegrationProviderServiceEnum!
  """true if the token configuration should be used"""
  isActive: Boolean!
  """The provider to connect to"""
  provider: IntegrationProvider!
}

"""An integration token that connects via OAuth1"""
type TeamMemberIntegrationAuthOAuth1 implements TeamMemberIntegrationAuth {
  """The token's unique identifier"""
  id: ID!
  """The team that the token is linked to"""
  teamId: ID!
  """The timestamp the token was created"""
  createdAt: DateTime!
  """The timestamp the token was updated at"""
  updatedAt: DateTime!
  """The ID of the integration provider this token belongs to"""
  providerId: ID!
  """
  The service this token is associated with, denormalized from the provider
  """
  service: IntegrationProviderServiceEnum!
  """true if the token configuration should be used"""
  isActive: Boolean!
  """The provider strategy this token connects to"""
  provider: IntegrationProviderOAuth1!
}

"""An integration token that connects via OAuth2"""
type TeamMemberIntegrationAuthOAuth2 implements TeamMemberIntegrationAuth {
  """The token's unique identifier"""
  id: ID!
  """The team that the token is linked to"""
  teamId: ID!
  """The timestamp the token was created"""
  createdAt: DateTime!
  """The timestamp the token was updated at"""
  updatedAt: DateTime!
  """The ID of the integration provider this token belongs to"""
  providerId: ID!
  """
  The service this token is associated with, denormalized from the provider
  """
  service: IntegrationProviderServiceEnum!
  """true if the token configuration should be used"""
  isActive: Boolean!
  """The provider strategy this token connects to"""
  provider: IntegrationProviderOAuth2!
  """The token used to connect to the provider"""
  accessToken: ID!
  """The scopes allowed on the provider"""
  scopes: String!
}

"""An integration authorization that connects via webhook"""
type TeamMemberIntegrationAuthWebhook implements TeamMemberIntegrationAuth {
  """The token's unique identifier"""
  id: ID!
  """The team that the token is linked to"""
  teamId: ID!
  """The timestamp the token was created"""
  createdAt: DateTime!
  """The timestamp the token was updated at"""
  updatedAt: DateTime!
  """The ID of the integration provider this token belongs to"""
  providerId: ID!
  """
  The service this token is associated with, denormalized from the provider
  """
  service: IntegrationProviderServiceEnum!
  """true if the token configuration should be used"""
  isActive: Boolean!
  """The provider strategy this token connects to"""
  provider: IntegrationProviderWebhook!
}

"""All integration connections available for a team member"""
type TeamMemberIntegrations {
  """Composite ID (userId::teamId)"""
  id: ID!
  """All things associated with an Atlassian integration for a team member"""
  atlassian: AtlassianIntegration
  """
  All things associated with a Jira Data Center integration for a team member
  """
  jiraServer: JiraServerIntegration!
  """All things associated with a GitHub integration for a team member"""
  github: GitHubIntegration
  """All things associated with a GitLab integration for a team member"""
  gitlab: GitLabIntegration!
  """All things associated with a Linear integration for a team member"""
  linear: LinearIntegration!
  """All things associated with a Mattermost integration for a team member"""
  mattermost: MattermostIntegration!
  """All things associated with a slack integration for a team member"""
  slack: SlackIntegration
  """
  All things associated with an Azure DevOps integration for a team member
  """
  azureDevOps: AzureDevOpsIntegration!
  """
  All things associated with a Microsoft Teams integration for a team member
  """
  msTeams: MSTeamsIntegration!
  """All things associated with a Gcal integration for a team member"""
  gcal: GcalIntegration
  """
  All things associated with a Google Drive (Meet transcript) integration for a team member
  """
  gdrive: GdriveIntegration!
  """All things associated with a Zoom integration for a team member"""
  zoom: ZoomIntegration!
}

"""
A notification sent to a team (deprecated in favor of typed Notification union members)
"""
interface TeamNotification {
  id: ID
  type: NotificationEnum
}

"""
Notification settings controlling which events get posted to an integration channel for a team
"""
type TeamNotificationSettings {
  id: ID!
  teamId: ID!
  """
  The ID of the integration provider (e.g. Slack workspace) these settings apply to
  """
  providerId: ID!
  """
  The channel in the integration to which these settings apply.
  Null for the default channel.
  """
  channel: ID
  """The events that trigger a notification"""
  events: [SlackNotificationEventEnum!]!
}

"""Minimal team fields shared across full and preview team types"""
interface TeamPartial {
  id: ID!
  name: String!
}

"""A lightweight team preview shown to users who are not yet members"""
type TeamPreview implements Node & TeamPartial {
  id: ID!
  name: String!
}

"""
A standup-style meeting where each team member responds to a shared prompt
"""
type TeamPromptMeeting implements NewMeeting {
  """
  The viewer's most recently generated AI inspiration items for a given integration service,
  cached for a short window. Empty if none have been generated recently.
  """
  inspirationItems(service: ServiceEnum!): [InspirationItem!]!
  """The prompt all team members are responding to"""
  meetingPrompt: String!
  """The tasks created within the meeting"""
  responses: [TeamPromptResponse!]!
  """The team prompt meeting member of the viewer"""
  viewerMeetingMember: TeamPromptMeetingMember
  """The number of responses generated in the meeting"""
  responseCount: Int!
  """The number of tasks generated in the meeting"""
  taskCount: Int!
  """The number of comments generated in the meeting"""
  commentCount: Int!
  """The unique meeting id. shortid."""
  id: ID!
  """
  The meeting series id this meeting is associated with if the meeting is recurring
  """
  meetingSeriesId: ID
  """
  The meeting series this meeting is associated with if the meeting is recurring
  """
  meetingSeries: MeetingSeries
  """The timestamp the meeting was created"""
  createdAt: DateTime!
  """
  The id of the user that created the meeting, null if user was hard deleted
  """
  createdBy: ID
  """The user that created the meeting, null if user was hard deleted"""
  createdByUser: User
  """The timestamp the meeting officially ended"""
  endedAt: DateTime
  """The location of the facilitator in the meeting"""
  facilitatorStageId: ID!
  """The userId (or anonymousId) of the most recent facilitator"""
  facilitatorUserId: ID!
  """The facilitator team member"""
  facilitator: TeamMember!
  """Is this locked for starter plans?"""
  locked: Boolean!
  """The team members that were active during the time of the meeting"""
  meetingMembers: [MeetingMember!]!
  """The auto-incrementing meeting number for the team"""
  meetingNumber: Int!
  meetingType: MeetingTypeEnum!
  """The name of the meeting"""
  name: String!
  """The organization this meeting belongs to"""
  organization: Organization!
  """
  The phases the meeting will go through, including all phase-specific state
  """
  phases: [NewMeetingPhase!]!
  """
  If meeting has a meeting series associated, this is the time the meeting will end
  """
  scheduledEndTime: DateTime
  """Is the OpenAI summary still being generated?"""
  isLoadingSummary: Boolean!
  """
  The OpenAI generated summary of all the content in the meeting, such as reflections, tasks, and comments. Undefined if the user doesnt have access to the feature or it's unavailable in this meeting type`
  """
  summary: String
  """The time the meeting summary was emailed to the team"""
  summarySentAt: DateTime
  """The tasks created within the meeting"""
  tasks: [Task!]!
  """The ID of the team that ran the meeting"""
  teamId: ID!
  """The team that ran the meeting"""
  team: Team!
  """The last time a meeting was updated (stage completed, finished, etc)"""
  updatedAt: DateTime
  """The previous meeting in the series if this meeting is recurring"""
  prevMeeting: TeamPromptMeeting
  """The next meeting in the series if this meeting is recurring"""
  nextMeeting: TeamPromptMeeting
  summaryPageId: ID
}

"""All the meeting specifics for a user in a team prompt meeting"""
type TeamPromptMeetingMember implements MeetingMember {
  """A composite of userId::meetingId"""
  id: ID!
  """true if present, false if absent, else null"""
  isCheckedIn: Boolean @deprecated(reason: "Members are checked in when they enter the meeting now & not created beforehand")
  meetingId: ID!
  meetingType: MeetingTypeEnum!
  teamId: ID!
  teamMember: TeamMember!
  user: User!
  userId: ID!
  """The last time a meeting was updated (stage completed, finished, etc)"""
  updatedAt: DateTime!
}

"""Meeting settings specific to team prompt (standup) meetings"""
type TeamPromptMeetingSettings implements TeamMeetingSettings {
  id: ID!
  """The type of meeting these settings apply to"""
  meetingType: MeetingTypeEnum!
  """The broad phase types that will be addressed during the meeting"""
  phaseTypes: [NewMeetingPhaseTypeEnum!]!
  """The ID of the team these settings belong to"""
  teamId: ID!
  """The team these settings belong to"""
  team: Team!
}

"""A response of a single team member in a team prompt"""
type TeamPromptResponse implements Reactable {
  """
  Team prompt response id in a format of `teamPromptResponse:idGeneratedByDatabase`
  """
  id: ID!
  """All the reactjis for the given reflection"""
  reactjis: [Reactji!]!
  """Id of the user who created the team prompt response"""
  userId: ID!
  """The user who created the response"""
  user: User!
  """the content of the response"""
  content: String!
  """the plain text content of the response"""
  plaintextContent: String!
  """The timestamp the response was created"""
  createdAt: DateTime!
  """The timestamp the response was updated at"""
  updatedAt: DateTime!
  """the shared sort order for reponses"""
  sortOrder: Float!
}

"""
The stage where a single team member writes their response to a team prompt
"""
type TeamPromptResponseStage implements NewMeetingStage & DiscussionThreadStage & NewMeetingTeamMemberStage {
  """Unique identifier"""
  id: ID!
  """The datetime the stage was completed"""
  endAt: DateTime
  """The ID of the meeting this stage belongs to"""
  meetingId: ID!
  """The meeting this stage belongs to"""
  meeting: NewMeeting!
  """
  true if the facilitator has completed this stage, else false. Should be boolean(endAt)
  """
  isComplete: Boolean!
  """true if any meeting participant can navigate to this stage"""
  isNavigable: Boolean!
  """true if the facilitator can navigate to this stage"""
  isNavigableByFacilitator: Boolean!
  """The phase this stage belongs to"""
  phase: NewMeetingPhase
  """The type of the phase"""
  phaseType: NewMeetingPhaseTypeEnum
  """The datetime the stage was started"""
  startAt: DateTime
  """Number of times the facilitator has visited this stage"""
  viewCount: Int
  """
  true if a time limit is set, false if end time is set, null if neither is set
  """
  isAsync: Boolean
  """true if the viewer is ready to advance, else false"""
  isViewerReady: Boolean!
  """User ids of those who are ready to advance to the next stage"""
  readyUserIds: [ID!]!
  """
  The datetime the phase is scheduled to be finished, null if no time limit or end time is set
  """
  scheduledEndTime: DateTime
  """
  The suggested ending datetime for a phase to be completed async, null if not enough data to make a suggestion
  """
  suggestedEndTime: DateTime
  """
  The suggested time limit for a phase to be completed together, null if not enough data to make a suggestion
  """
  suggestedTimeLimit: Float
  teamId: ID!
  """
  The number of milliseconds left before the scheduled end time. Useful for unsynced client clocks. null if scheduledEndTime is null
  """
  timeRemaining: Float
  """
  The 0-based position of this stage within its phase, ordered by sortOrder.
  """
  stageIdx: Int!
  """The ID to find the discussion that goes in the stage"""
  discussionId: ID!
  """The discussion about the stage"""
  discussion: Discussion!
  """The ID of the team member whose response this stage captures"""
  teamMemberId: ID!
  """The team member this stage belongs to"""
  teamMember: TeamMember!
  """The response to the prompt"""
  response: TeamPromptResponse
  """The meeting member that is the focus for this phase item"""
  meetingMember: MeetingMember!
}

"""
The meeting phase where each of the team members can respond to prompts
"""
type TeamPromptResponsesPhase implements NewMeetingPhase {
  """shortid"""
  id: ID!
  meetingId: ID!
  teamId: ID!
  """The type of phase"""
  phaseType: NewMeetingPhaseTypeEnum!
  stages: [TeamPromptResponseStage!]!
}

"""A periodic snapshot of team-level statistics"""
type TeamStat {
  id: ID!
  createdAt: DateTime!
}

"""
Subscription payload for team-level changes (meetings, members, templates, integrations)
"""
type TeamSubscriptionPayload {
  fieldName: String!
  AcceptTeamInvitationPayload: AcceptTeamInvitationPayload
  AddAgendaItemPayload: AddAgendaItemPayload
  AddAtlassianAuthPayload: AddAtlassianAuthPayload
  AddGitHubAuthPayload: AddGitHubAuthPayload
  AddSlackAuthPayload: AddSlackAuthPayload
  ArchiveTeamPayload: ArchiveTeamPayload
  BatchArchiveTasksSuccess: BatchArchiveTasksSuccess
  DenyPushInvitationPayload: DenyPushInvitationPayload
  DowngradeToStarterPayload: DowngradeToStarterPayload
  EndCheckInSuccess: EndCheckInSuccess
  EndRetrospectiveSuccess: EndRetrospectiveSuccess
  EndSprintPokerSuccess: EndSprintPokerSuccess
  EndTeamPromptSuccess: EndTeamPromptSuccess
  NavigateMeetingPayload: NavigateMeetingPayload
  PushInvitationPayload: PushInvitationPayload
  PromoteToTeamLeadPayload: PromoteToTeamLeadPayload
  RemoveAgendaItemPayload: RemoveAgendaItemPayload
  RemoveOrgUsersSuccess: RemoveOrgUsersSuccess
  RemoveTeamMemberPayload: RemoveTeamMemberPayload
  RenameMeetingSuccess: RenameMeetingSuccess
  SelectTemplatePayload: SelectTemplatePayload
  SetTeamNotificationSettingSuccess: SetTeamNotificationSettingSuccess
  StartCheckInSuccess: StartCheckInSuccess
  StartRetrospectiveSuccess: StartRetrospectiveSuccess
  StartSprintPokerSuccess: StartSprintPokerSuccess
  StartTeamPromptSuccess: StartTeamPromptSuccess
  UpdateAgendaItemPayload: UpdateAgendaItemPayload
  UpdateCreditCardPayload: UpdateCreditCardPayload
  UpdateTeamNamePayload: UpdateTeamNamePayload
  UpgradeToTeamTierSuccess: UpgradeToTeamTierSuccess
  AddReflectTemplateSuccess: AddReflectTemplateSuccess
  AddPokerTemplateSuccess: AddPokerTemplateSuccess
  AddReflectTemplatePromptPayload: AddReflectTemplatePromptPayload
  AddPokerTemplateDimensionPayload: AddPokerTemplateDimensionPayload
  AddPokerTemplateScalePayload: AddPokerTemplateScalePayload
  AddPokerTemplateScaleValuePayload: AddPokerTemplateScaleValuePayload
  MoveReflectTemplatePromptPayload: MoveReflectTemplatePromptPayload
  MovePokerTemplateDimensionPayload: MovePokerTemplateDimensionPayload
  ReflectTemplatePromptUpdateDescriptionPayload: ReflectTemplatePromptUpdateDescriptionPayload
  PokerTemplateDimensionUpdateDescriptionPayload: PokerTemplateDimensionUpdateDescriptionPayload
  ReflectTemplatePromptUpdateGroupColorPayload: ReflectTemplatePromptUpdateGroupColorPayload
  RemoveAtlassianAuthPayload: RemoveAtlassianAuthPayload
  RemoveGitHubAuthPayload: RemoveGitHubAuthPayload
  RemoveSlackAuthPayload: RemoveSlackAuthPayload
  RemoveReflectTemplatePayload: RemoveReflectTemplatePayload
  RemovePokerTemplatePayload: RemovePokerTemplatePayload
  RemoveReflectTemplatePromptPayload: RemoveReflectTemplatePromptPayload
  RemovePokerTemplateDimensionPayload: RemovePokerTemplateDimensionPayload
  RemovePokerTemplateScalePayload: RemovePokerTemplateScalePayload
  RenameMeetingTemplatePayload: RenameMeetingTemplatePayload
  RenameReflectTemplatePromptPayload: RenameReflectTemplatePromptPayload
  RenamePokerTemplateDimensionPayload: RenamePokerTemplateDimensionPayload
  RenamePokerTemplateScalePayload: RenamePokerTemplateScalePayload
  RemovePokerTemplateScaleValuePayload: RemovePokerTemplateScaleValuePayload
  SetMeetingSettingsPayload: SetMeetingSettingsPayload
  SetSlackNotificationPayload: SetSlackNotificationPayload
  UpdatePokerTemplateDimensionScalePayload: UpdatePokerTemplateDimensionScalePayload
  UpdatePokerTemplateScaleValuePayload: UpdatePokerTemplateScaleValuePayload
  UpdateUserProfilePayload: UpdateUserProfilePayload
  PersistJiraSearchQuerySuccess: PersistJiraSearchQuerySuccess
  MovePokerTemplateScaleValueSuccess: MovePokerTemplateScaleValueSuccess
  UpdateAzureDevOpsDimensionFieldSuccess: UpdateAzureDevOpsDimensionFieldSuccess
  SetDefaultSlackChannelSuccess: SetDefaultSlackChannelSuccess
  UpdateGitHubDimensionFieldSuccess: UpdateGitHubDimensionFieldSuccess
  UpdateRecurrenceSettingsSuccess: UpdateRecurrenceSettingsSuccess
  UpdateDimensionFieldSuccess: UpdateDimensionFieldSuccess
  UpdateTemplateCategorySuccess: UpdateTemplateCategorySuccess
  JoinTeamSuccess: JoinTeamSuccess
  SetJiraDisplayFieldIdsPayload: SetJiraDisplayFieldIdsPayload
}

"""
A scoring dimension in a sprint poker template (e.g. Effort, Complexity)
"""
type TemplateDimension {
  """Unique identifier"""
  id: ID!
  createdAt: DateTime!
  """true if the dimension is currently used by the team, else false"""
  isActive: Boolean!
  """
  The datetime that the dimension was removed. Null if it has not been removed.
  """
  removedAt: DateTime
  """The ID of the team that owns this dimension"""
  teamId: ID!
  """The team that owns this dimension"""
  team: Team!
  updatedAt: DateTime!
  """the order of the dimensions in the template"""
  sortOrder: String!
  """The ID of the poker template this dimension belongs to"""
  templateId: ID!
  """The template that this dimension belongs to"""
  template: PokerTemplate!
  """The name of the dimension"""
  name: String!
  """
  The description to the dimension name for further context. A long version of the dimension name.
  """
  description: String!
  """The ID of the scale used to score this dimension"""
  scaleId: ID!
  """scale used in this dimension"""
  selectedScale: TemplateScale!
}

"""
An immutable snapshot of a TemplateDimension, stored with completed meetings
"""
type TemplateDimensionRef {
  id: ID!
  """the order of the dimensions in the template"""
  sortOrder: Float!
  """The name of the dimension"""
  name: String!
  """
  The md5 hash identifying the immutable scale ref used in this dimension
  """
  scaleRefId: ID!
  """scale used in this dimension"""
  scale: TemplateScaleRef!
}

"""
A set of labeled values used to score a poker template dimension (e.g. Fibonacci, T-shirt sizes)
"""
type TemplateScale {
  """Unique identifier"""
  id: ID!
  createdAt: DateTime!
  """true if the scale is currently used by the team, else false"""
  isActive: Boolean!
  """True if this is a starter/default scale; false otherwise"""
  isStarter: Boolean!
  """
  The datetime that the scale was removed. Null if it has not been removed.
  """
  removedAt: DateTime
  """The ID of the team that owns this scale"""
  teamId: ID!
  """The team that owns this template scale"""
  team: Team!
  updatedAt: DateTime!
  """The title of the scale used in the template"""
  name: String!
  """The dimensions currently using this scale"""
  dimensions: [TemplateDimension!]!
  """The values used in this scale"""
  values: [TemplateScaleValue!]!
}

"""A value for a scale"""
input TemplateScaleInput {
  """The color used to visually group a scale value"""
  color: String!
  """The label for this value, e.g., XS, M, L"""
  label: String!
}

"""
An immutable snapshot of a TemplateScale, stored with completed meetings
"""
type TemplateScaleRef {
  """md5 hash of the scale values, used as a stable identifier"""
  id: ID!
  createdAt: DateTime!
  """The title of the scale used in the template"""
  name: String!
  """The values used in this scale"""
  values: [TemplateScaleValue!]!
}

"""A value for a scale."""
type TemplateScaleValue {
  id: ID!
  """The id of the scale this value belongs to"""
  scaleId: ID!
  """The color used to visually group a scale value"""
  color: String!
  """The label for this value, e.g., XS, M, L"""
  label: String!
  """the order of the scale value in this scale"""
  sortOrder: Int!
}

"""An item that can be put in a thread"""
interface Threadable {
  """shortid"""
  id: ID!
  """The timestamp the item was created"""
  createdAt: DateTime!
  """The userId that created the item"""
  createdBy: ID
  """The user that created the item"""
  createdByUser: User
  """the replies to this threadable item"""
  replies: [Threadable!]!
  """
  The FK of the discussion this task was created in. Null if task was not created in a discussion
  """
  discussionId: ID
  """the parent, if this threadable is a reply, else null"""
  threadParentId: ID
  """the order of this threadable, relative to threadParentId"""
  threadSortOrder: Int
  """The timestamp the item was updated"""
  updatedAt: DateTime!
}

"""A connection to a list of items."""
type ThreadableConnection {
  """Page info with strings (sortOrder) as cursors"""
  pageInfo: PageInfo
  """A list of edges."""
  edges: [ThreadableEdge!]!
  """Any errors that prevented the query from returning the full results"""
  error: String
}

"""An edge in a connection."""
type ThreadableEdge {
  """The item at the end of the edge"""
  node: Threadable!
  cursor: String
}

"""The pay tier of the team"""
enum TierEnum {
  """Free tier with limited features"""
  starter
  """Paid team tier"""
  team
  """Enterprise tier with advanced features"""
  enterprise
}

"""A past event surfaced in the viewer's activity timeline"""
interface TimelineEvent {
  """Unique identifier"""
  id: ID!
  """When the event was created"""
  createdAt: DateTime!
  """
  the number of times the user has interacted with (ie clicked) this event
  """
  interactionCount: Int!
  """true if the timeline event is active, false if archived"""
  isActive: Boolean!
  """
  The orgId this event is associated with. Null if not traceable to one org
  """
  orgId: ID
  """The organization this event is associated with"""
  organization: Organization
  """the number of times the user has seen this event"""
  seenCount: Int!
  """
  The teamId this event is associated with. Null if not traceable to one team
  """
  teamId: ID
  """The team that can see this event"""
  team: Team
  """The specific type of event"""
  type: TimelineEventEnum!
  """The ID of the user who can see this event"""
  userId: ID!
  """The user who can see this event"""
  user: User!
}

"""A timeline event for a completed check-in (action) meeting"""
type TimelineEventCompletedActionMeeting implements TimelineEvent {
  """Unique identifier"""
  id: ID!
  """When the event was created"""
  createdAt: DateTime!
  """
  the number of times the user has interacted with (ie clicked) this event
  """
  interactionCount: Int!
  """true if the timeline event is active, false if archived"""
  isActive: Boolean!
  """The orgId this event is associated with"""
  orgId: ID!
  """The organization this event is associated with"""
  organization: Organization
  """the number of times the user has seen this event"""
  seenCount: Int!
  """The teamId this event is associated with"""
  teamId: ID!
  """The team that can see this event"""
  team: Team!
  """The specific type of event"""
  type: TimelineEventEnum!
  """The ID of the user who can see this event"""
  userId: ID!
  """The user who can see this event"""
  user: User!
  """The meeting that was completed"""
  meeting: ActionMeeting!
  """The meetingId that was completed, null if legacyMeetingId is present"""
  meetingId: ID!
}

"""A timeline event for a completed retrospective meeting"""
type TimelineEventCompletedRetroMeeting implements TimelineEvent {
  """Unique identifier"""
  id: ID!
  """When the event was created"""
  createdAt: DateTime!
  """
  the number of times the user has interacted with (ie clicked) this event
  """
  interactionCount: Int!
  """true if the timeline event is active, false if archived"""
  isActive: Boolean!
  """The orgId this event is associated with"""
  orgId: ID!
  """The organization this event is associated with"""
  organization: Organization
  """the number of times the user has seen this event"""
  seenCount: Int!
  """The teamId this event is associated with"""
  teamId: ID!
  """The team that can see this event"""
  team: Team!
  """The specific type of event"""
  type: TimelineEventEnum!
  """The ID of the user who can see this event"""
  userId: ID!
  """The user who can see this event"""
  user: User!
  """The meeting that was completed"""
  meeting: RetrospectiveMeeting!
  """The meetingId that was completed"""
  meetingId: ID!
}

"""A paginated list of timeline events"""
type TimelineEventConnection {
  """Page info with cursors coerced to ISO8601 dates"""
  pageInfo: PageInfoDateCursor
  """A list of edges."""
  edges: [TimelineEventEdge!]!
}

"""A cursor-based edge wrapping a single timeline event"""
type TimelineEventEdge {
  """The item at the end of the edge"""
  node: TimelineEvent!
  cursor: DateTime
}

"""The type of timeline event"""
enum TimelineEventEnum {
  """A retrospective meeting was completed"""
  retroComplete
  """A check-in meeting was completed"""
  actionComplete
  """The user joined Parabol for the first time"""
  joinedParabol
  """A new team was created"""
  createdTeam
  """A sprint poker meeting was completed"""
  POKER_COMPLETE
  """A standup (team prompt) meeting was completed"""
  TEAM_PROMPT_COMPLETE
}

"""A timeline event for when the user first joined Parabol"""
type TimelineEventJoinedParabol implements TimelineEvent {
  """Unique identifier"""
  id: ID!
  """When the event was created"""
  createdAt: DateTime!
  """
  the number of times the user has interacted with (ie clicked) this event
  """
  interactionCount: Int!
  """true if the timeline event is active, false if archived"""
  isActive: Boolean!
  """
  The orgId this event is associated with. Null if not traceable to one org
  """
  orgId: ID
  """The organization this event is associated with"""
  organization: Organization
  """the number of times the user has seen this event"""
  seenCount: Int!
  """
  The teamId this event is associated with. Null if not traceable to one team
  """
  teamId: ID
  """The team that can see this event"""
  team: Team
  """The specific type of event"""
  type: TimelineEventEnum!
  """The ID of the user who can see this event"""
  userId: ID!
  """The user who can see this event"""
  user: User!
}

"""A timeline event for a completed sprint poker meeting"""
type TimelineEventPokerComplete implements TimelineEvent {
  """Unique identifier"""
  id: ID!
  """When the event was created"""
  createdAt: DateTime!
  """
  the number of times the user has interacted with (ie clicked) this event
  """
  interactionCount: Int!
  """true if the timeline event is active, false if archived"""
  isActive: Boolean!
  """The orgId this event is associated with"""
  orgId: ID!
  """The organization this event is associated with"""
  organization: Organization
  """the number of times the user has seen this event"""
  seenCount: Int!
  """The teamId this event is associated with"""
  teamId: ID!
  """The team that can see this event"""
  team: Team!
  """The specific type of event"""
  type: TimelineEventEnum!
  """The ID of the user who can see this event"""
  userId: ID!
  """The user who can see this event"""
  user: User!
  """The meeting that was completed"""
  meeting: PokerMeeting!
  """The meetingId that was completed"""
  meetingId: ID!
}

"""A timeline event for when a new team was created"""
type TimelineEventTeamCreated implements TimelineEvent {
  """Unique identifier"""
  id: ID!
  """When the event was created"""
  createdAt: DateTime!
  """
  the number of times the user has interacted with (ie clicked) this event
  """
  interactionCount: Int!
  """true if the timeline event is active, false if archived"""
  isActive: Boolean!
  """The orgId this event is associated with"""
  orgId: ID!
  """The organization this event is associated with"""
  organization: Organization
  """the number of times the user has seen this event"""
  seenCount: Int!
  """The teamId this event is associated with"""
  teamId: ID!
  """The team that can see this event"""
  team: Team!
  """The specific type of event"""
  type: TimelineEventEnum!
  """The ID of the user who can see this event"""
  userId: ID!
  """The user who can see this event"""
  user: User!
}

"""A timeline event for a completed standup (team prompt) meeting"""
type TimelineEventTeamPromptComplete implements TimelineEvent {
  """Unique identifier"""
  id: ID!
  """When the event was created"""
  createdAt: DateTime!
  """
  the number of times the user has interacted with (ie clicked) this event
  """
  interactionCount: Int!
  """true if the timeline event is active, false if archived"""
  isActive: Boolean!
  """The orgId this event is associated with"""
  orgId: ID!
  """The organization this event is associated with"""
  organization: Organization
  """the number of times the user has seen this event"""
  seenCount: Int!
  """The teamId this event is associated with"""
  teamId: ID!
  """The team that can see this event"""
  team: Team!
  """The specific type of event"""
  type: TimelineEventEnum!
  """The ID of the user who can see this event"""
  userId: ID!
  """The user who can see this event"""
  user: User!
  """The meeting that was completed"""
  meeting: TeamPromptMeeting!
  """The meetingId that was completed"""
  meetingId: ID!
}

"""Return value for toggleAIFeatures mutation"""
union ToggleAIFeaturesPayload = ErrorPayload | ToggleAIFeaturesSuccess

"""Success result for toggleAIFeatures mutation"""
type ToggleAIFeaturesSuccess {
  """The organization with the updated AI features setting"""
  organization: Organization!
}

"""Success result for toggleFavoriteTemplate mutation"""
type ToggleFavoriteTemplateSuccess {
  """The user whose favorite templates were updated"""
  user: User!
}

"""Return value for toggleFeatureFlag mutation"""
union ToggleFeatureFlagPayload = ErrorPayload | ToggleFeatureFlagSuccess

"""Success result for toggleFeatureFlag mutation"""
type ToggleFeatureFlagSuccess {
  """The feature flag that was toggled"""
  featureFlag: OwnedFeatureFlag!
}

"""Success result for togglePageInvitationEmail mutation"""
type TogglePageInvitationEmailSuccess {
  """The user whose page invitation email preference was updated"""
  user: User!
}

"""Return value for togglePageInvitationEmail mutation"""
union TogglePageInvitationEmailPayload = ErrorPayload | TogglePageInvitationEmailSuccess

"""Return value for toggleSummaryEmail mutation"""
union ToggleSummaryEmailPayload = ErrorPayload | ToggleSummaryEmailSuccess

"""Success result for toggleSummaryEmail mutation"""
type ToggleSummaryEmailSuccess {
  """The user whose meeting summary email preference was updated"""
  user: User!
}

"""Return value for toggleTeamDrawer mutation"""
union ToggleTeamDrawerPayload = ErrorPayload | ToggleTeamDrawerSuccess

"""Success result for toggleTeamDrawer mutation"""
type ToggleTeamDrawerSuccess {
  """The team member with the updated open drawer state"""
  teamMember: TeamMember!
}

"""Return value for toggleTeamPrivacy, which could be an error"""
union ToggleTeamPrivacyPayload = ErrorPayload | ToggleTeamPrivacySuccess

"""Success result for toggleTeamPrivacy mutation"""
type ToggleTeamPrivacySuccess {
  """The team with the updated privacy setting"""
  team: Team!
}

"""A block of the meeting transcription with a speaker and text"""
type TranscriptBlock {
  """The speaker who said the words"""
  speaker: String!
  """The words that the speaker said"""
  words: String!
}

"""A valid URL string"""
scalar URL

"""Success result for ungroupReflection mutation"""
type UngroupReflectionSuccess {
  """The meeting where the reflection was ungrouped"""
  meeting: RetrospectiveMeeting!
}

"""Return value for unlinkMattermostChannel mutation"""
union UnlinkMattermostChannelPayload = ErrorPayload | UnlinkMattermostChannelSuccess

"""Success result for unlinkMattermostChannel mutation"""
type UnlinkMattermostChannelSuccess {
  """The team whose Mattermost channel was unlinked"""
  teamId: ID!
  """The remaining linked Mattermost channel IDs for the team"""
  linkedChannels: [ID!]!
  """The id of the team notification settings that were removed"""
  teamNotificationSettingsId: ID!
}

"""Input for updating an existing agenda item"""
input UpdateAgendaItemInput {
  """The unique agenda item ID, composed of a teamId::shortid"""
  id: ID!
  """The content of the agenda item"""
  content: String
  """True if agenda item has been pinned"""
  pinned: Boolean
  """True if not processed or deleted"""
  isActive: Boolean
  """The sort order of the agenda item in the list"""
  sortOrder: String
}

"""Return value for updateAgendaItem mutation"""
type UpdateAgendaItemPayload {
  """The updated agenda item"""
  agendaItem: AgendaItem
  meetingId: ID
  """The meeting with the updated agenda item, if any"""
  meeting: NewMeeting
  error: StandardMutationError
}

"""Return value for updateAutoJoin, which could be an error"""
union UpdateAutoJoinPayload = ErrorPayload | UpdateAutoJoinSuccess

"""Success result for updateAutoJoin mutation"""
type UpdateAutoJoinSuccess {
  """The teams that were updated"""
  updatedTeams: [Team!]!
}

"""Return value for updateAzureDevOpsDimensionField mutation"""
union UpdateAzureDevOpsDimensionFieldPayload = ErrorPayload | UpdateAzureDevOpsDimensionFieldSuccess

"""Success result for updateAzureDevOpsDimensionField mutation"""
type UpdateAzureDevOpsDimensionFieldSuccess {
  """The team whose dimension field mapping was updated"""
  teamId: ID!
  """The poker meeting the update was triggered from, if any"""
  meetingId: ID
  team: Team!
  """The poker meeting the field was updated from"""
  meeting: PokerMeeting
}

"""Return value for updateCommentContent mutation"""
union UpdateCommentContentPayload = ErrorPayload | UpdateCommentContentSuccess

"""Success result for updateCommentContent mutation"""
type UpdateCommentContentSuccess {
  """the comment with updated content"""
  comment: Comment!
}

"""Return value for updateCreditCard, which could be an error"""
union UpdateCreditCardPayload = ErrorPayload | UpdateCreditCardSuccess

type UpdateCreditCardSuccess {
  """The teams that were updated with the new payment method"""
  teamsUpdated: [Team!]!
  """The org that was updated with the new payment method"""
  organization: Organization!
  """
  The client secret from the Stripe subscription. Used for client-side retrieval using a publishable key.
  """
  stripeSubscriptionClientSecret: String!
}

"""Return value for updateDimensionField mutation"""
union UpdateDimensionFieldPayload = UpdateDimensionFieldSuccess | ErrorPayload

"""Success result for updateDimensionField mutation"""
type UpdateDimensionFieldSuccess {
  """The team whose dimension field mapping was updated"""
  teamId: ID!
  """The poker meeting the update was triggered from, if any"""
  meetingId: ID
  team: Team!
  """The poker meeting the field was updated from"""
  meeting: PokerMeeting
}

"""
Input for broadcasting a drag position update during a retro grouping phase
"""
input UpdateDragLocationInput {
  """ID of the drag operation"""
  id: ID!
  """Viewport height of the dragging client"""
  clientHeight: Float!
  """Viewport width of the dragging client"""
  clientWidth: Float!
  meetingId: ID!
  """The primary key of the item being dragged"""
  sourceId: ID!
  """The estimated destination of the item being dragged"""
  targetId: ID
  """The teamId to broadcast the message to"""
  teamId: ID!
  """horizontal distance from the top left of the target"""
  targetOffsetX: Float
  """vertical distance from the top left of the target"""
  targetOffsetY: Float
  """the left of the source, relative to the client window"""
  clientX: Float
  """the top of the source, relative to the client window"""
  clientY: Float
}

"""Payload broadcast to teammates when a reflection card is being dragged"""
type UpdateDragLocationPayload {
  """The drag as sent from the team member"""
  remoteDrag: RemoteReflectionDrag
  """The user performing the drag"""
  userId: ID!
}

"""Return value for updateGitHubDimensionField mutation"""
union UpdateGitHubDimensionFieldPayload = ErrorPayload | UpdateGitHubDimensionFieldSuccess

"""Success result for updateGitHubDimensionField mutation"""
type UpdateGitHubDimensionFieldSuccess {
  """The team whose dimension field mapping was updated"""
  teamId: ID!
  """The poker meeting the update was triggered from"""
  meetingId: ID!
  team: Team!
  """The poker meeting the field was updated from"""
  meeting: PokerMeeting!
}

"""Return value for updateGitLabDimensionField mutation"""
union UpdateGitLabDimensionFieldPayload = ErrorPayload | UpdateGitLabDimensionFieldSuccess

"""Success result for updateGitLabDimensionField mutation"""
type UpdateGitLabDimensionFieldSuccess {
  """The team whose dimension field mapping was updated"""
  teamId: ID
  """The poker meeting the update was triggered from, if any"""
  meetingId: ID
  team: Team
  meeting: NewMeeting
}

"""Input for updating an existing integration provider's configuration"""
input UpdateIntegrationProviderInput {
  """The ID of the integration provider to update"""
  id: ID!
  """The new scope for this provider (org, team)"""
  scope: IntegrationProviderEditableScopeEnum
  """The new team id for this provider for team scope"""
  teamId: ID
  """The new org id for this provider for org scope"""
  orgId: ID
  """
  Webhook provider metadata, has to be non-null if token type is webhook, refactor once we get https://github.com/graphql/graphql-spec/pull/825
  """
  webhookProviderMetadataInput: IntegrationProviderMetadataInputWebhook
  """
  OAuth2 provider metadata, has to be non-null if token type is OAuth2, refactor once we get https://github.com/graphql/graphql-spec/pull/825
  """
  oAuth2ProviderMetadataInput: IntegrationProviderMetadataInputOAuth2
}

"""Return value for updateIntegrationProvider mutation"""
union UpdateIntegrationProviderPayload = ErrorPayload | UpdateIntegrationProviderSuccess

"""Success result for updateIntegrationProvider mutation"""
type UpdateIntegrationProviderSuccess {
  """The provider that was updated"""
  provider: IntegrationProvider!
}

"""Return value for updateLinearDimensionField mutation"""
union UpdateLinearDimensionFieldPayload = ErrorPayload | UpdateLinearDimensionFieldSuccess

"""Success result for updateLinearDimensionField mutation"""
type UpdateLinearDimensionFieldSuccess {
  """ID of the team whose dimension field mapping was updated"""
  teamId: ID
  """ID of the poker meeting the update was triggered from, if any"""
  meetingId: ID
  team: Team
  meeting: NewMeeting
}

"""Return value for updateMeetingPrompt, which could be an error"""
union UpdateMeetingPromptPayload = UpdateMeetingPromptSuccess | ErrorPayload

"""Success result for updateMeetingPrompt mutation"""
type UpdateMeetingPromptSuccess {
  """ID of the updated meeting"""
  meetingId: ID!
  """The updated meeting"""
  meeting: TeamPromptMeeting!
}

"""Return value for updateMeetingSeries, which could be an error"""
union UpdateMeetingSeriesPayload = UpdateMeetingSeriesSuccess | ErrorPayload

"""Success result for updateMeetingSeries mutation"""
type UpdateMeetingSeriesSuccess {
  """The updated meeting series"""
  meetingSeries: MeetingSeries!
}

"""Return value for updateMeetingTemplate, which could be an error"""
union UpdateMeetingTemplatePayload = ErrorPayload | UpdateMeetingTemplateSuccess

"""Success result for updateMeetingTemplate mutation"""
type UpdateMeetingTemplateSuccess {
  """The updated meeting"""
  meeting: NewMeeting!
}

"""Return value for updateNewCheckInQuestion mutation"""
type UpdateNewCheckInQuestionPayload {
  error: StandardMutationError
  """The updated meeting"""
  meeting: NewMeeting
}

"""Return value for updateOAuthAPIProvider mutation"""
type UpdateOAuthAPIProviderPayload {
  """The updated OAuth API provider"""
  provider: OAuthAPIProvider!
  """The organization that owns the provider"""
  organization: Organization!
}

"""Input for updating an organization's settings"""
input UpdateOrgInput {
  """The org ID"""
  id: ID!
  """The name of the org"""
  name: String
}

"""Return value for updateOrg mutation"""
type UpdateOrgPayload {
  error: StandardMutationError
  """The updated org"""
  organization: Organization
}

"""Return value for updatePageAccess mutation"""
type UpdatePageAccessPayload {
  """The page whose access was updated"""
  page: Page!
  """The section of the page that was updated"""
  pageSection: PageSectionEnum!
}

"""Return value for updatePage mutation"""
type UpdatePagePayload {
  """The updated page"""
  page: Page!
  """The section of the page that was updated"""
  pageSection: PageSectionEnum!
}

"""Success result for updatePersonalAccessToken mutation"""
type UpdatePersonalAccessTokenSuccess {
  """The updated personal access token"""
  personalAccessToken: PersonalAccessToken!
}

input UpdatePokerScopeItemInput {
  """
  The location of the single source of truth (e.g. a jira-integrated parabol task would be "jira")
  """
  service: TaskServiceEnum!
  """
  If vanilla parabol task, taskId. If integrated parabol task, integrationHash
  """
  serviceTaskId: ID!
  """The action to perform"""
  action: AddOrDeleteEnum!
}

"""Return object for UpdatePokerScopePayload"""
union UpdatePokerScopePayload = ErrorPayload | UpdatePokerScopeSuccess

type UpdatePokerScopeSuccess {
  """The meeting with the updated estimate phases"""
  meeting: PokerMeeting!
  """The estimate stages added to the meeting"""
  newStages: [EstimateStage!]!
}

"""Return value for updatePokerTemplateDimensionScale mutation"""
type UpdatePokerTemplateDimensionScalePayload {
  error: StandardMutationError
  """The updated template dimension"""
  dimension: TemplateDimension
}

"""Return value for updatePokerTemplateScaleValue mutation"""
type UpdatePokerTemplateScaleValuePayload {
  error: StandardMutationError
  """The updated template scale"""
  scale: TemplateScale
}

"""Return value for updateRecurrenceSettings, which could be an error"""
union UpdateRecurrenceSettingsPayload = UpdateRecurrenceSettingsSuccess | ErrorPayload

"""Success result for updateRecurrenceSettings mutation"""
type UpdateRecurrenceSettingsSuccess {
  """The updated meeting"""
  meeting: NewMeeting!
}

"""Return value for updateReflectionContent mutation"""
type UpdateReflectionContentPayload {
  error: StandardMutationError
  """The meeting containing the updated reflection"""
  meeting: NewMeeting
  """The updated reflection"""
  reflection: RetroReflection
}

"""Return value for updateReflectionGroupTitle mutation"""
type UpdateReflectionGroupTitlePayload {
  error: StandardMutationError
  """The meeting containing the updated reflection group"""
  meeting: NewMeeting
  """The updated reflection group"""
  reflectionGroup: RetroReflectionGroup
}

"""Return object for UpdateRetroMaxVotesPayload"""
union UpdateRetroMaxVotesPayload = ErrorPayload | UpdateRetroMaxVotesSuccess

"""Success result for updateRetroMaxVotes mutation"""
type UpdateRetroMaxVotesSuccess {
  """The meeting with the updated max votes"""
  meeting: RetrospectiveMeeting!
}

"""Return value for updateSCIM mutation"""
type UpdateSCIMPayload {
  """The updated SAML configuration containing the SCIM settings"""
  saml: SAML!
  """The updated authentication type."""
  scimAuthenticationType: SCIMAuthenticationTypeEnum
  """The OAuth client ID used for SCIM authentication."""
  scimOAuthClientId: ID
  """The OAuth client secret used for SCIM authentication."""
  scimOAuthClientSecret: ID
  """The bearer token used for SCIM authentication."""
  scimBearerToken: String
}

"""Return value for updateTaskDueDate mutation"""
type UpdateTaskDueDatePayload {
  error: StandardMutationError
  """The task with the updated due date"""
  task: Task
}

"""Input for updating an existing task"""
input UpdateTaskInput {
  """The task id"""
  id: ID!
  """Updated task content (rich text)"""
  content: String
  """Updated sort order for display"""
  sortOrder: Float
  """Updated task status"""
  status: TaskStatusEnum
  """
  userId, the owner of the task. This can be null if the task is not assigned to anyone.
  """
  userId: ID
}

"""Return value for updateTask mutation"""
type UpdateTaskPayload {
  error: StandardMutationError
  """The updated task"""
  task: Task
  """If a task was just turned private, its ID, else null"""
  privatizedTaskId: ID
  """Notification created if a user was newly involved in the task"""
  addedNotification: NotifyTaskInvolves
}

"""Return value for updateTeamName mutation"""
type UpdateTeamNamePayload {
  error: StandardMutationError
  """The team with the updated name"""
  team: Team
}

"""Return value for updateTeamSortOrder mutation"""
type UpdateTeamSortOrderPayload {
  """The team with the updated sort order"""
  team: Team!
  """The user whose team sort order was updated"""
  user: User!
}

"""Return value for updateTemplateCategory, which could be an error"""
union UpdateTemplateCategoryPayload = ErrorPayload | UpdateTemplateCategorySuccess

type UpdateTemplateCategorySuccess {
  """The template with the updated mainCategory"""
  template: MeetingTemplate!
}

"""Return object for UpdateTemplateScopePayload"""
union UpdateTemplateScopePayload = ErrorPayload | UpdateTemplateScopeSuccess

"""Success result for updateTemplateScope mutation"""
type UpdateTemplateScopeSuccess {
  """
  The updated template; if downscoped, may not reflect the full sharing state
  """
  template: MeetingTemplate!
  """
  If downscoping a previously used template, this will be the replacement
  """
  clonedTemplate: MeetingTemplate
  """The settings that contain the teamTemplates array that was modified"""
  settings: TeamMeetingSettings!
}

"""Input for updating a user's profile"""
input UpdateUserProfileInput {
  """The name, as confirmed by the user"""
  preferredName: String
}

"""Return value for updateUserProfile mutation"""
type UpdateUserProfilePayload {
  error: StandardMutationError
  """The user with the updated profile"""
  user: User
}

"""Payload containing a notification that was updated"""
type UpdatedNotification {
  """The updated notification"""
  updatedNotification: Notification!
}

"""Input for updating a team's name or picture"""
input UpdatedTeamInput {
  """The team ID"""
  id: ID!
  """The name of the team"""
  name: String!
  """A link to the team's profile image."""
  picture: URL
}

"""The meeting phase where all team members give updates one-by-one"""
type UpdatesPhase implements NewMeetingPhase {
  """Unique phase ID"""
  id: ID!
  """ID of the meeting this phase belongs to"""
  meetingId: ID!
  """ID of the team running the meeting"""
  teamId: ID!
  """The type of phase"""
  phaseType: NewMeetingPhaseTypeEnum!
  """Ordered stages, one per team member"""
  stages: [UpdatesStage!]!
}

"""A stage that focuses on a single team member"""
type UpdatesStage implements NewMeetingStage & NewMeetingTeamMemberStage {
  """Unique stage ID"""
  id: ID!
  """The datetime the stage was completed"""
  endAt: DateTime
  """ID of the meeting this stage belongs to"""
  meetingId: ID!
  """The meeting this stage belongs to"""
  meeting: NewMeeting!
  """
  true if the facilitator has completed this stage, else false. Should be boolean(endAt)
  """
  isComplete: Boolean!
  """true if any meeting participant can navigate to this stage"""
  isNavigable: Boolean!
  """true if the facilitator can navigate to this stage"""
  isNavigableByFacilitator: Boolean!
  """The phase this stage belongs to"""
  phase: NewMeetingPhase
  """The type of the phase"""
  phaseType: NewMeetingPhaseTypeEnum
  """The datetime the stage was started"""
  startAt: DateTime
  """Number of times the facilitator has visited this stage"""
  viewCount: Int
  """
  true if a time limit is set, false if end time is set, null if neither is set
  """
  isAsync: Boolean
  """true if the viewer is ready to advance, else false"""
  isViewerReady: Boolean!
  """User ids of those who are ready to advance to the next stage"""
  readyUserIds: [ID!]!
  """
  The datetime the phase is scheduled to be finished, null if no time limit or end time is set
  """
  scheduledEndTime: DateTime
  """
  The suggested ending datetime for a phase to be completed async, null if not enough data to make a suggestion
  """
  suggestedEndTime: DateTime
  """
  The suggested time limit for a phase to be completed together, null if not enough data to make a suggestion
  """
  suggestedTimeLimit: Float
  """ID of the team running the meeting"""
  teamId: ID!
  """
  The number of milliseconds left before the scheduled end time. Useful for unsynced client clocks. null if scheduledEndTime is null
  """
  timeRemaining: Float
  """
  The 0-based position of this stage within its phase, ordered by sortOrder.
  """
  stageIdx: Int!
  """The meeting member that is the focus for this phase item"""
  meetingMember: MeetingMember!
  """ID of the team member who is the focus for this stage"""
  teamMemberId: ID!
  """The team member that is the focus for this phase item"""
  teamMember: TeamMember!
}

"""Return value for upgradeToTeamTier, which could be an error"""
union UpgradeToTeamTierPayload = ErrorPayload | UpgradeToTeamTierSuccess

"""Success result for upgradeToTeamTier mutation"""
type UpgradeToTeamTierSuccess {
  """The new org on the team tier"""
  organization: Organization!
  """The updated teams under the org"""
  teams: [Team!]!
}

"""Return value for uploadIdPMetadata mutation"""
union UploadIdPMetadataPayload = ErrorPayload | UploadIdPMetadataSuccess

"""Success result for uploadIdPMetadata mutation"""
type UploadIdPMetadataSuccess {
  """URL of the uploaded IdP metadata"""
  url: String!
}

"""Return object for uploadUserAsset"""
union UploadUserAssetPayload = ErrorPayload | UploadUserAssetSuccess

"""Success result for uploadUserAsset mutation"""
type UploadUserAssetSuccess {
  """The URL for the newly uploaded asset"""
  url: String!
  """The name of the newly uploaded asset"""
  name: String!
  """The MIME type of the newly uploaded asset"""
  type: String!
  """The size of the newly uploaded asset in bytes"""
  size: Int!
}

"""Return value for upsertTeamPromptResponse mutation"""
union UpsertTeamPromptResponsePayload = UpsertTeamPromptResponseSuccess | ErrorPayload

"""Success result for upsertTeamPromptResponse mutation"""
type UpsertTeamPromptResponseSuccess {
  """ID of the created or updated team prompt response"""
  teamPromptResponseId: ID!
  """ID of the standup meeting this response belongs to"""
  meetingId: ID!
  """The created/updated team prompt response"""
  teamPromptResponse: TeamPromptResponse
  """The updated meeting"""
  meeting: NewMeeting
}

"""The user account profile"""
type User implements UserPartial {
  """The userId provided by us"""
  id: ID!
  """The optional pseudoId for the user"""
  pseudoId: String
  archivedTasks(
    first: Int!
    """the datetime cursor"""
    after: DateTime
    """The unique team ID"""
    teamId: ID!
  ): TaskConnection @scope(name: TASKS_READ)
  archivedTasksCount(
    """The unique team ID"""
    teamId: ID!
  ): Int
  """The timestamp the user was created"""
  createdAt: DateTime!
  """The user email"""
  email: Email!
  """
  An array of objects with information about the user's identities.
        More than one will exists in case accounts are linked
  """
  identities: [AuthIdentity]
  """
  The SAML identity provider sign-on URL for the user's email domain, if configured
  """
  samlIdP: String
  """
  true if the user is not currently being billed for service. removed on every websocket handshake
  """
  inactive: Boolean
  invoices(
    first: Int!
    """the datetime cursor"""
    after: DateTime
    """The id of the organization"""
    orgId: ID!
  ): InvoiceConnection! @scope(name: ORGS_READ)
  """true if the user is a billing leader on any organization, else false"""
  isAnyBillingLeader: Boolean!
  """true if the user is currently online"""
  isConnected: Boolean
  """true if the user is the first to sign up from their domain, else false"""
  isPatient0: Boolean!
  """true if the user is the first to sign up from their domain, else false"""
  isPatientZero: Boolean! @deprecated(reason: "Use isPatient0 instead")
  """the reason the user account was removed"""
  reasonRemoved: String
  """true if the user was removed from parabol, else false"""
  isRemoved: Boolean!
  """true if all user sessions are being recorded in LogRocket, else false"""
  isWatched: Boolean!
  """the endedAt timestamp of the most recent meeting they were a member of"""
  lastMetAt: DateTime
  """The number of meetings the user has attended"""
  meetingCount: Int!
  """
  The largest number of consecutive months the user has checked into a meeting
  """
  monthlyStreakMax: Int!
  """
  The number of consecutive 30-day intervals that the user has checked into a meeting as of this moment
  """
  monthlyStreakCurrent: Int!
  """the most important actions for the user to perform"""
  suggestedActions: [SuggestedAction!]!
  """The timeline of important events for the viewer"""
  timeline(
    """the datetime cursor"""
    after: DateTime
    """the number of timeline events to return"""
    first: Int!
    """
    a list of team Ids that you want timeline events for. if null, will return timeline events for all possible active teams
    """
    teamIds: [ID!]
    eventTypes: [TimelineEventEnum!]
    """
    true to only return archived timeline events; false to return active ones
    """
    archived: Boolean = false
  ): TimelineEventConnection! @scope(name: MEETINGS_READ)
  """the comments and tasks created from the discussion"""
  discussion(
    """The ID of the discussion"""
    id: ID!
  ): Discussion @scope(name: COMMENTS_READ)
  """the ID of the newest feature, null if the user has dismissed it"""
  newFeatureId: ID
  """The new feature released by Parabol. null if the user already hid it"""
  newFeature: NewFeatureBroadcast
  """The application-specific name, defaults to email before the tld"""
  preferredName: String!
  """
  The last day the user connected via websocket or navigated to a common area
  """
  lastSeenAt: DateTime!
  """
  The meeting member associated with this user, if a meeting is currently in progress
  """
  meetingMember(
    """The specific meeting ID"""
    meetingId: ID!
  ): MeetingMember @scope(name: MEETINGS_READ)
  """A previous meeting that the user was in (present or absent)"""
  meeting(
    """The meeting ID"""
    meetingId: ID!
  ): NewMeeting @scope(name: MEETINGS_READ)
  """
  A meeting series the viewer can access. Used to manage scheduled-only series
  (where no meeting has spawned yet) and to deep-link to series-level configuration.
  Returns null when the series does not exist or the viewer is not on the team.
  """
  meetingSeries(
    """The meeting series ID"""
    meetingSeriesId: ID!
  ): MeetingSeries @scope(name: MEETINGS_READ)
  """all the notifications for a single user"""
  notifications(first: Int!, after: DateTime, types: [NotificationEnum!]): NotificationConnection!
  """get a single organization"""
  organization(
    """the orgId"""
    orgId: ID!
  ): Organization @scope(name: ORGS_READ)
  """The connection between a user and an organization"""
  organizationUser(
    """the orgId"""
    orgId: ID!
  ): OrganizationUser @scope(name: ORGS_READ)
  """A single user that is connected to a single organization"""
  organizationUsers: [OrganizationUser!]! @scope(name: ORGS_READ)
  """Get the list of all organizations a user belongs to"""
  organizations: [Organization!]! @scope(name: ORGS_READ)
  """
  a string with message stating that the user is over the free tier limit, else null
  """
  overLimitCopy: String
  """Whether the user should receive a meeting summary email"""
  sendSummaryEmail: Boolean!
  """Whether the user should receive page invitation emails"""
  sendPageInvitationEmail: Boolean!
  """
  The reflection groups that are similar to the selected reflection in the Spotlight
  """
  similarReflectionGroups(
    """The id of the selected reflection group in the Spotlight"""
    reflectionGroupId: ID!
    """Only return reflection groups that match the search query"""
    searchQuery: String!
  ): [RetroReflectionGroup!]! @scope(name: MEETINGS_READ)
  tasks(
    """the number of tasks to return"""
    first: Int!
    """the datetime cursor"""
    after: DateTime
    """
    a list of user Ids that you want tasks for. if null, will return tasks for all possible team members. An id is null if it is not assigned to anyone.
    """
    userIds: [ID!]
    """
    a list of team Ids that you want tasks for. if null, will return tasks for all possible active teams
    """
    teamIds: [ID!]
    """true to only return archived tasks; false to return active tasks"""
    archived: Boolean = false
    """filter tasks by the chosen statuses"""
    statusFilters: [TaskStatusEnum!]
    """only return tasks which match the given filter query"""
    filterQuery: String
    """
    if true, include unassigned tasks. If false, only return assigned tasks
    """
    includeUnassigned: Boolean = false
  ): TaskConnection! @scope(name: TASKS_READ)
  """A query for a team"""
  team(
    """The team ID for the desired team"""
    teamId: ID!
  ): Team @scope(name: TEAMS_READ)
  """
  The invitation sent to the user, even if it was sent before they were a user
  """
  teamInvitation(
    """
    The meetingId to check for the invitation, if teamId not available (e.g. on a meeting route)
    """
    meetingId: ID
    """The teamId to check for the invitation"""
    teamId: ID
  ): TeamInvitationPayload! @scope(name: TEAMS_READ)
  """all the teams the user is on that the viewer can see."""
  teams(
    """
    If true, returns archived teams as well; otherwise only return active teams. Default to false.
    """
    includeArchived: Boolean = false
  ): [Team!]! @scope(name: TEAMS_READ)
  """The team member associated with this user"""
  teamMember(
    """The team the user is on"""
    teamId: ID!
    """
    If null, defaults to the team member for this user. Else, will grab the team member. Returns null if not on team.
    """
    userId: ID
  ): TeamMember @scope(name: TEAMS_READ)
  """IDs of all teams the user is a part of that the viewer can see"""
  tms: [ID!]! @scope(name: TEAMS_READ)
  """The timestamp the user was last updated"""
  updatedAt: DateTime
  """The assumed company this organization belongs to"""
  company: Company @scope(name: ORGS_READ)
  """The domains the user is a lead of"""
  domains: [Company!]! @scope(name: ORGS_READ)
  """Domain join request"""
  domainJoinRequest(requestId: ID!): DomainJoinRequest @scope(name: ORGS_READ)
  """The user's favorite meeting templates"""
  favoriteTemplates: [MeetingTemplate!]! @scope(name: TEMPLATES_READ)
  """Whether the user has a feature flag enabled or not"""
  featureFlag(featureName: String!): Boolean!
  """url of user's profile picture"""
  picture: URL!
  """
  url of user's raster profile picture (if user profile pic is an SVG, raster will be a PNG)
  """
  rasterPicture: URL!
  """
  Check whether the viewer can access a given entity. This can be used to distinguish errors from unauthorized access which requires an invite.
  """
  canAccess(
    """the entity to check"""
    entity: CanAccessEntity!
    """the id of the entity"""
    id: ID!
  ): Boolean!
  """The highest tier of all the user's organizations"""
  highestTier: TierEnum!
  """A connection of activities available to the user"""
  availableTemplates(
    first: Int!
    """The cursor, which is the templateId"""
    after: ID
    """An optional argument to filter by template type"""
    type: MeetingTypeEnum
  ): MeetingTemplateConnection! @scope(name: TEMPLATES_READ)
  """Activities available to the user matching the search"""
  templateSearch(
    """Search query"""
    search: String!
  ): [MeetingTemplate!]! @scope(name: TEMPLATES_READ)
  """
  A prototype for a team experience. Includes meeting templates and meeting types that have no templates
  """
  activity(
    """The ID of the activity. templateId or standup or checkin"""
    activityId: ID!
  ): MeetingTemplate @scope(name: TEMPLATES_READ)
  """A query to parse/validate SAML metadata for a given domain"""
  parseSAMLMetadata(
    """
    URL of a blob of XML from the IdP describing how to handle authentication
    """
    metadataURL: String!
    """The name of the company, used as a slug in signon URLs"""
    domain: String!
  ): ParseSAMLMetadataPayload! @scope(name: ORGS_READ)
  """The number of free custom retro templates remaining"""
  freeCustomRetroTemplatesRemaining: Int!
  """The number of free custom poker templates remaining"""
  freeCustomPokerTemplatesRemaining: Int!
  """AI-provided Insights"""
  pageInsights(meetingIds: [ID!]!, prompt: String!, responseFormat: ContentFormatEnum = markdown): [String!]!
  """
  Prompts to send to an AI endpoint, e.g. pageInsights. Limited to 20 user-defined prompts + n shared
  """
  aiPrompts: [AIPrompt!]!
  """Paginated list of meetings for the given teams and types"""
  meetings(
    """The max number of meetings to return"""
    first: Int!
    """Filter to meetings belonging to these teams"""
    teamIds: [ID!]!
    """Filter to these meeting types"""
    meetingTypes: [MeetingTypeEnum!]!
    """The createdAt DateTime used as a cursor"""
    after: DateTime
    """The createdAt DateTime used as an end cursor"""
    before: DateTime!
  ): MeetingConnection! @scope(name: MEETINGS_READ)
  """All the pages accessible by a user"""
  pages(
    teamId: ID
    """
    a null value means parentPageId = null. not provided (undefined) means it is unfiltered
    """
    parentPageId: ID
    """The first n records to return"""
    first: Int!
    """The pagination cursor, if any"""
    after: String
    """
    true to query top-level private pages. false to query top-level sharerd pages. ignored if parentPageId or teamId is present
    """
    isPrivate: Boolean
    """true is the page has been archived and is ready for deletion"""
    isArchived: Boolean
    """
    A string of text to filter the results. If an empty string is provided, it returns top suggestions
    """
    textFilter: String
  ): PageConnection! @scope(name: PAGES_READ)
  search(
    """The string to search for"""
    query: String!
    first: Int!
    after: String
    type: SearchTypeEnum!
    teamIds: [ID!]
    startAt: DateTime
    endAt: DateTime
    dateField: SearchDateTypeEnum
    """
    Alpha controls the weight given to vector (semantic) search vs. keyword search. 1.0 = pure vector, 0.0 = pure keyword. Defaults to 0.75.
    """
    alpha: Float
  ): SearchResultConnection!
  """The user's personal access tokens for API access"""
  personalAccessTokens: [PersonalAccessToken!]!
}

"""Generic payload to send when user signs up"""
type UserLogInPayload {
  """Error details, if sign-in failed"""
  error: StandardMutationError
  """ID of the signed-in user"""
  userId: ID
  """If a new user is created"""
  isNewUser: Boolean
  """The newly created user, or the existing user"""
  user: User
}

"""Minimal user fields shared across User and UserPreview"""
interface UserPartial {
  """The user ID"""
  id: ID!
  """The user's email address"""
  email: Email!
  """The user's display name"""
  preferredName: String!
  """URL of the user's profile picture"""
  picture: URL!
}

"""Minimal public user profile, used where full User data is not needed"""
type UserPreview implements UserPartial {
  id: ID!
  email: Email!
  preferredName: String!
  picture: URL!
}

"""A count of the number of account tiers a user belongs to."""
type UserTiersCount {
  """The number of starter orgs the user is active upon"""
  tierStarterCount: Int
  """The number of orgs on the team tier the user is active upon"""
  tierTeamCount: Int
  """
  The number of orgs on the team tier the user holds the role of Billing Leader
  """
  tierTeamBillingLeaderCount: Int
  """The user these counts belong to"""
  user: User
}

"""Result of verifying a team invitation token"""
type VerifiedInvitationPayload {
  """Null if the invitation is valid; otherwise the reason it failed"""
  errorType: TeamInvitationErrorEnum
  """
  The name of the person that sent the invitation, present if errorType is expired
  """
  inviterName: String
  """
  The email of the person that sent the invitation, present if errorType is expired
  """
  inviterEmail: String
  """true if the mx record is hosted by google, else falsy"""
  isGoogle: Boolean
  """A string to redirect to the SSO IdP, else null"""
  ssoURL: String
  """The valid invitation, if any"""
  teamInvitation: TeamInvitation
  """Name of the inviting team, present if invitation exists"""
  teamName: String
  """ID of the meeting the invite is linked to, if any"""
  meetingId: ID
  """Name of the meeting the invite is linked to, if any"""
  meetingName: String
  """Type of the meeting the invite is linked to, if any"""
  meetingType: MeetingTypeEnum
  """The userId of the invitee, if already a parabol user"""
  userId: ID
  """The invitee, if already a parabol user, present if errorType is null"""
  user: User
}

"""Return object for VoteForPokerStoryPayload"""
union VoteForPokerStoryPayload = ErrorPayload | VoteForPokerStorySuccess

"""Success result for voteForPokerStory mutation"""
type VoteForPokerStorySuccess {
  """The stage that holds the updated scores"""
  stage: EstimateStage!
}

"""Return value for voteForReflectionGroup mutation"""
type VoteForReflectionGroupPayload {
  error: StandardMutationError
  """The meeting where the vote occurred"""
  meeting: RetrospectiveMeeting
  """The meeting member who voted"""
  meetingMember: RetrospectiveMeetingMember
  """The reflection group that received the vote"""
  reflectionGroup: RetroReflectionGroup
  """The stages that were locked or unlocked by having at least 1 vote"""
  unlockedStages: [NewMeetingStage!]
}

"""Payload sent when the voting phase of a retrospective is complete"""
type VotePhaseCompletePayload {
  """The current meeting"""
  meeting: RetrospectiveMeeting
}

"""
Zoom integration info for a team member, used for meeting transcript imports
"""
type ZoomIntegration {
  """The global provider configuration for Zoom OAuth"""
  cloudProvider: IntegrationProviderOAuth2
  """True if the user has an active Zoom integration for this team"""
  isActive: Boolean!
}