schema.graphql

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

directive @sanitize(allowedTags: [String], maxLength: Int, minLength: Int, pattern: String) on INPUT_FIELD_DEFINITION

type AddDiscoverFeedError {
  errorCodes: [AddDiscoverFeedErrorCode!]!
}

enum AddDiscoverFeedErrorCode {
  BAD_REQUEST
  CONFLICT
  NOT_FOUND
  UNAUTHORIZED
}

input AddDiscoverFeedInput {
  url: String!
}

union AddDiscoverFeedResult = AddDiscoverFeedError | AddDiscoverFeedSuccess

type AddDiscoverFeedSuccess {
  feed: DiscoverFeed!
}

type AddPopularReadError {
  errorCodes: [AddPopularReadErrorCode!]!
}

enum AddPopularReadErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union AddPopularReadResult = AddPopularReadError | AddPopularReadSuccess

type AddPopularReadSuccess {
  pageId: String!
}

enum AllowedReply {
  CONFIRM
  OKAY
  SUBSCRIBE
  YES
}

type ApiKey {
  createdAt: Date!
  expiresAt: Date!
  id: ID!
  key: String
  name: String!
  scopes: [String!]
  usedAt: Date
}

type ApiKeysError {
  errorCodes: [ApiKeysErrorCode!]!
}

enum ApiKeysErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union ApiKeysResult = ApiKeysError | ApiKeysSuccess

type ApiKeysSuccess {
  apiKeys: [ApiKey!]!
}

type ArchiveLinkError {
  errorCodes: [ArchiveLinkErrorCode!]!
  message: String!
}

enum ArchiveLinkErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

input ArchiveLinkInput {
  archived: Boolean!
  linkId: ID!
}

union ArchiveLinkResult = ArchiveLinkError | ArchiveLinkSuccess

type ArchiveLinkSuccess {
  linkId: String!
  message: String!
}

type Article {
  author: String
  content: String!
  contentReader: ContentReader!
  createdAt: Date!
  description: String
  directionality: DirectionalityType
  feedContent: String
  folder: String!
  hasContent: Boolean
  hash: String!
  highlights(input: ArticleHighlightsInput): [Highlight!]!
  id: ID!
  image: String
  isArchived: Boolean!
  labels: [Label!]
  language: String
  linkId: ID
  originalArticleUrl: String
  originalHtml: String
  pageType: PageType
  postedByViewer: Boolean
  publishedAt: Date
  readAt: Date
  readingProgressAnchorIndex: Int!
  readingProgressPercent: Float!
  readingProgressTopPercent: Float
  recommendations: [Recommendation!]
  savedAt: Date!
  savedByViewer: Boolean
  shareInfo: LinkShareInfo
  sharedComment: String
  siteIcon: String
  siteName: String
  slug: String!
  state: ArticleSavingRequestStatus
  subscription: String
  title: String!
  unsubHttpUrl: String
  unsubMailTo: String
  updatedAt: Date
  uploadFileId: ID
  url: String!
  wordsCount: Int
}

type ArticleEdge {
  cursor: String!
  node: Article!
}

type ArticleError {
  errorCodes: [ArticleErrorCode!]!
}

enum ArticleErrorCode {
  BAD_DATA
  NOT_FOUND
  UNAUTHORIZED
}

input ArticleHighlightsInput {
  includeFriends: Boolean
}

union ArticleResult = ArticleError | ArticleSuccess

type ArticleSavingRequest {
  article: Article @deprecated(reason: "article has been replaced with slug")
  createdAt: Date!
  errorCode: CreateArticleErrorCode
  id: ID!
  slug: String!
  status: ArticleSavingRequestStatus!
  updatedAt: Date
  url: String!
  user: User!
  userId: ID! @deprecated(reason: "userId has been replaced with user")
}

type ArticleSavingRequestError {
  errorCodes: [ArticleSavingRequestErrorCode!]!
}

enum ArticleSavingRequestErrorCode {
  BAD_DATA
  NOT_FOUND
  UNAUTHORIZED
}

union ArticleSavingRequestResult = ArticleSavingRequestError | ArticleSavingRequestSuccess

enum ArticleSavingRequestStatus {
  ARCHIVED
  CONTENT_NOT_FETCHED
  DELETED
  FAILED
  PROCESSING
  SUCCEEDED
}

type ArticleSavingRequestSuccess {
  articleSavingRequest: ArticleSavingRequest!
}

type ArticleSuccess {
  article: Article!
}

type ArticlesError {
  errorCodes: [ArticlesErrorCode!]!
}

enum ArticlesErrorCode {
  UNAUTHORIZED
}

union ArticlesResult = ArticlesError | ArticlesSuccess

type ArticlesSuccess {
  edges: [ArticleEdge!]!
  pageInfo: PageInfo!
}

type BulkActionError {
  errorCodes: [BulkActionErrorCode!]!
}

enum BulkActionErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union BulkActionResult = BulkActionError | BulkActionSuccess

type BulkActionSuccess {
  success: Boolean!
}

enum BulkActionType {
  ADD_LABELS
  ARCHIVE
  DELETE
  MARK_AS_READ
  MARK_AS_SEEN
  MOVE_TO_FOLDER
}

enum ContentReader {
  EPUB
  PDF
  WEB
}

type CreateArticleError {
  errorCodes: [CreateArticleErrorCode!]!
}

enum CreateArticleErrorCode {
  ELASTIC_ERROR
  NOT_ALLOWED_TO_PARSE
  PAYLOAD_TOO_LARGE
  UNABLE_TO_FETCH
  UNABLE_TO_PARSE
  UNAUTHORIZED
  UPLOAD_FILE_MISSING
}

input CreateArticleInput {
  articleSavingRequestId: ID
  folder: String
  labels: [CreateLabelInput!]
  preparedDocument: PreparedDocumentInput
  publishedAt: Date
  rssFeedUrl: String
  savedAt: Date
  skipParsing: Boolean
  source: String
  state: ArticleSavingRequestStatus
  uploadFileId: ID
  url: String!
}

union CreateArticleResult = CreateArticleError | CreateArticleSuccess

type CreateArticleSavingRequestError {
  errorCodes: [CreateArticleSavingRequestErrorCode!]!
}

enum CreateArticleSavingRequestErrorCode {
  BAD_DATA
  UNAUTHORIZED
}

input CreateArticleSavingRequestInput {
  url: String!
}

union CreateArticleSavingRequestResult = CreateArticleSavingRequestError | CreateArticleSavingRequestSuccess

type CreateArticleSavingRequestSuccess {
  articleSavingRequest: ArticleSavingRequest!
}

type CreateArticleSuccess {
  created: Boolean!
  createdArticle: Article!
  user: User!
}

type CreateFolderPolicyError {
  errorCodes: [CreateFolderPolicyErrorCode!]!
}

enum CreateFolderPolicyErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

input CreateFolderPolicyInput {
  action: FolderPolicyAction!
  afterDays: Int!
  folder: String!
}

union CreateFolderPolicyResult = CreateFolderPolicyError | CreateFolderPolicySuccess

type CreateFolderPolicySuccess {
  policy: FolderPolicy!
}

type CreateGroupError {
  errorCodes: [CreateGroupErrorCode!]!
}

enum CreateGroupErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

input CreateGroupInput {
  description: String
  expiresInDays: Int
  maxMembers: Int
  name: String!
  onlyAdminCanPost: Boolean
  onlyAdminCanSeeMembers: Boolean
  topics: [String!]
}

union CreateGroupResult = CreateGroupError | CreateGroupSuccess

type CreateGroupSuccess {
  group: RecommendationGroup!
}

type CreateHighlightError {
  errorCodes: [CreateHighlightErrorCode!]!
}

enum CreateHighlightErrorCode {
  ALREADY_EXISTS
  BAD_DATA
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

input CreateHighlightInput {
  annotation: String
  articleId: ID!
  color: String
  highlightPositionAnchorIndex: Int
  highlightPositionPercent: Float
  html: String
  id: ID!
  patch: String
  prefix: String
  quote: String
  representation: RepresentationType
  sharedAt: Date
  shortId: String!
  suffix: String
  type: HighlightType
}

type CreateHighlightReplyError {
  errorCodes: [CreateHighlightReplyErrorCode!]!
}

enum CreateHighlightReplyErrorCode {
  EMPTY_ANNOTATION
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

input CreateHighlightReplyInput {
  highlightId: ID!
  text: String!
}

union CreateHighlightReplyResult = CreateHighlightReplyError | CreateHighlightReplySuccess

type CreateHighlightReplySuccess {
  highlightReply: HighlightReply!
}

union CreateHighlightResult = CreateHighlightError | CreateHighlightSuccess

type CreateHighlightSuccess {
  highlight: Highlight!
}

type CreateLabelError {
  errorCodes: [CreateLabelErrorCode!]!
}

enum CreateLabelErrorCode {
  BAD_REQUEST
  LABEL_ALREADY_EXISTS
  NOT_FOUND
  UNAUTHORIZED
}

input CreateLabelInput {
  color: String
  description: String
  name: String!
}

union CreateLabelResult = CreateLabelError | CreateLabelSuccess

type CreateLabelSuccess {
  label: Label!
}

type CreateNewsletterEmailError {
  errorCodes: [CreateNewsletterEmailErrorCode!]!
}

enum CreateNewsletterEmailErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

input CreateNewsletterEmailInput {
  description: String
  folder: String
  name: String
}

union CreateNewsletterEmailResult = CreateNewsletterEmailError | CreateNewsletterEmailSuccess

type CreateNewsletterEmailSuccess {
  newsletterEmail: NewsletterEmail!
}

type CreateReactionError {
  errorCodes: [CreateReactionErrorCode!]!
}

enum CreateReactionErrorCode {
  BAD_CODE
  BAD_TARGET
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

input CreateReactionInput {
  code: ReactionType!
  highlightId: ID
  userArticleId: ID
}

union CreateReactionResult = CreateReactionError | CreateReactionSuccess

type CreateReactionSuccess {
  reaction: Reaction!
}

type CreateReminderError {
  errorCodes: [CreateReminderErrorCode!]!
}

enum CreateReminderErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input CreateReminderInput {
  archiveUntil: Boolean!
  clientRequestId: ID
  linkId: ID
  remindAt: Date!
  sendNotification: Boolean!
}

union CreateReminderResult = CreateReminderError | CreateReminderSuccess

type CreateReminderSuccess {
  reminder: Reminder!
}

scalar Date

type DeleteAccountError {
  errorCodes: [DeleteAccountErrorCode!]!
}

enum DeleteAccountErrorCode {
  FORBIDDEN
  UNAUTHORIZED
  USER_NOT_FOUND
}

union DeleteAccountResult = DeleteAccountError | DeleteAccountSuccess

type DeleteAccountSuccess {
  userID: ID!
}

type DeleteDiscoverArticleError {
  errorCodes: [DeleteDiscoverArticleErrorCode!]!
}

enum DeleteDiscoverArticleErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input DeleteDiscoverArticleInput {
  discoverArticleId: ID!
}

union DeleteDiscoverArticleResult = DeleteDiscoverArticleError | DeleteDiscoverArticleSuccess

type DeleteDiscoverArticleSuccess {
  id: ID!
}

type DeleteDiscoverFeedError {
  errorCodes: [DeleteDiscoverFeedErrorCode!]!
}

enum DeleteDiscoverFeedErrorCode {
  BAD_REQUEST
  CONFLICT
  NOT_FOUND
  UNAUTHORIZED
}

input DeleteDiscoverFeedInput {
  feedId: ID!
}

union DeleteDiscoverFeedResult = DeleteDiscoverFeedError | DeleteDiscoverFeedSuccess

type DeleteDiscoverFeedSuccess {
  id: String!
}

type DeleteFilterError {
  errorCodes: [DeleteFilterErrorCode!]!
}

enum DeleteFilterErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union DeleteFilterResult = DeleteFilterError | DeleteFilterSuccess

type DeleteFilterSuccess {
  filter: Filter!
}

type DeleteFolderPolicyError {
  errorCodes: [DeleteFolderPolicyErrorCode!]!
}

enum DeleteFolderPolicyErrorCode {
  UNAUTHORIZED
}

union DeleteFolderPolicyResult = DeleteFolderPolicyError | DeleteFolderPolicySuccess

type DeleteFolderPolicySuccess {
  success: Boolean!
}

type DeleteHighlightError {
  errorCodes: [DeleteHighlightErrorCode!]!
}

enum DeleteHighlightErrorCode {
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

type DeleteHighlightReplyError {
  errorCodes: [DeleteHighlightReplyErrorCode!]!
}

enum DeleteHighlightReplyErrorCode {
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

union DeleteHighlightReplyResult = DeleteHighlightReplyError | DeleteHighlightReplySuccess

type DeleteHighlightReplySuccess {
  highlightReply: HighlightReply!
}

union DeleteHighlightResult = DeleteHighlightError | DeleteHighlightSuccess

type DeleteHighlightSuccess {
  highlight: Highlight!
}

type DeleteIntegrationError {
  errorCodes: [DeleteIntegrationErrorCode!]!
}

enum DeleteIntegrationErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union DeleteIntegrationResult = DeleteIntegrationError | DeleteIntegrationSuccess

type DeleteIntegrationSuccess {
  integration: Integration!
}

type DeleteLabelError {
  errorCodes: [DeleteLabelErrorCode!]!
}

enum DeleteLabelErrorCode {
  BAD_REQUEST
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

union DeleteLabelResult = DeleteLabelError | DeleteLabelSuccess

type DeleteLabelSuccess {
  label: Label!
}

type DeleteNewsletterEmailError {
  errorCodes: [DeleteNewsletterEmailErrorCode!]!
}

enum DeleteNewsletterEmailErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union DeleteNewsletterEmailResult = DeleteNewsletterEmailError | DeleteNewsletterEmailSuccess

type DeleteNewsletterEmailSuccess {
  newsletterEmail: NewsletterEmail!
}

type DeleteReactionError {
  errorCodes: [DeleteReactionErrorCode!]!
}

enum DeleteReactionErrorCode {
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

union DeleteReactionResult = DeleteReactionError | DeleteReactionSuccess

type DeleteReactionSuccess {
  reaction: Reaction!
}

type DeleteReminderError {
  errorCodes: [DeleteReminderErrorCode!]!
}

enum DeleteReminderErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union DeleteReminderResult = DeleteReminderError | DeleteReminderSuccess

type DeleteReminderSuccess {
  reminder: Reminder!
}

type DeleteRuleError {
  errorCodes: [DeleteRuleErrorCode!]!
}

enum DeleteRuleErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union DeleteRuleResult = DeleteRuleError | DeleteRuleSuccess

type DeleteRuleSuccess {
  rule: Rule!
}

type DeleteWebhookError {
  errorCodes: [DeleteWebhookErrorCode!]!
}

enum DeleteWebhookErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union DeleteWebhookResult = DeleteWebhookError | DeleteWebhookSuccess

type DeleteWebhookSuccess {
  webhook: Webhook!
}

type DeviceToken {
  createdAt: Date!
  id: ID!
  token: String!
}

type DeviceTokensError {
  errorCodes: [DeviceTokensErrorCode!]!
}

enum DeviceTokensErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union DeviceTokensResult = DeviceTokensError | DeviceTokensSuccess

type DeviceTokensSuccess {
  deviceTokens: [DeviceToken!]!
}

type DigestConfig {
  channels: [String]
}

input DigestConfigInput {
  channels: [String]
}

enum DirectionalityType {
  LTR
  RTL
}

type DiscoverFeed {
  description: String
  id: ID!
  image: String
  link: String!
  title: String!
  type: String!
  visibleName: String
}

type DiscoverFeedArticle {
  author: String
  description: String!
  feed: String!
  id: ID!
  image: String
  publishedDate: Date
  savedId: String
  savedLinkUrl: String
  siteName: String
  slug: String!
  title: String!
  url: String!
}

type DiscoverFeedError {
  errorCodes: [DiscoverFeedErrorCode!]!
}

enum DiscoverFeedErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union DiscoverFeedResult = DiscoverFeedError | DiscoverFeedSuccess

type DiscoverFeedSuccess {
  feeds: [DiscoverFeed]!
}

type DiscoverTopic {
  description: String!
  name: String!
}

type EditDiscoverFeedError {
  errorCodes: [EditDiscoverFeedErrorCode!]!
}

enum EditDiscoverFeedErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input EditDiscoverFeedInput {
  feedId: ID!
  name: String!
}

union EditDiscoverFeedResult = EditDiscoverFeedError | EditDiscoverFeedSuccess

type EditDiscoverFeedSuccess {
  id: ID!
}

type EmptyTrashError {
  errorCodes: [EmptyTrashErrorCode!]!
}

enum EmptyTrashErrorCode {
  UNAUTHORIZED
}

union EmptyTrashResult = EmptyTrashError | EmptyTrashSuccess

type EmptyTrashSuccess {
  success: Boolean
}

enum ErrorCode {
  BAD_REQUEST
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

type ExportToIntegrationError {
  errorCodes: [ExportToIntegrationErrorCode!]!
}

enum ExportToIntegrationErrorCode {
  FAILED_TO_CREATE_TASK
  UNAUTHORIZED
}

union ExportToIntegrationResult = ExportToIntegrationError | ExportToIntegrationSuccess

type ExportToIntegrationSuccess {
  task: Task!
}

type Feature {
  createdAt: Date!
  expiresAt: Date
  grantedAt: Date
  id: ID!
  name: String!
  token: String!
  updatedAt: Date
}

type Feed {
  author: String
  createdAt: Date
  description: String
  id: ID
  image: String
  publishedAt: Date
  title: String!
  type: String
  updatedAt: Date
  url: String!
}

type FeedArticle {
  annotationsCount: Int
  article: Article!
  highlight: Highlight
  highlightsCount: Int
  id: ID!
  reactions: [Reaction!]!
  sharedAt: Date!
  sharedBy: User!
  sharedComment: String
  sharedWithHighlights: Boolean
}

type FeedArticleEdge {
  cursor: String!
  node: FeedArticle!
}

type FeedArticlesError {
  errorCodes: [FeedArticlesErrorCode!]!
}

enum FeedArticlesErrorCode {
  UNAUTHORIZED
}

union FeedArticlesResult = FeedArticlesError | FeedArticlesSuccess

type FeedArticlesSuccess {
  edges: [FeedArticleEdge!]!
  pageInfo: PageInfo!
}

type FeedEdge {
  cursor: String!
  node: Feed!
}

type FeedsError {
  errorCodes: [FeedsErrorCode!]!
}

enum FeedsErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

input FeedsInput {
  after: String
  first: Int
  query: String
  sort: SortParams
}

union FeedsResult = FeedsError | FeedsSuccess

type FeedsSuccess {
  edges: [FeedEdge!]!
  pageInfo: PageInfo!
}

type FetchContentError {
  errorCodes: [FetchContentErrorCode!]!
}

enum FetchContentErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union FetchContentResult = FetchContentError | FetchContentSuccess

type FetchContentSuccess {
  success: Boolean!
}

enum FetchContentType {
  ALWAYS
  NEVER
  WHEN_EMPTY
}

type Filter {
  category: String
  createdAt: Date!
  defaultFilter: Boolean
  description: String
  filter: String!
  folder: String
  id: ID!
  name: String!
  position: Int!
  updatedAt: Date
  visible: Boolean
}

type FiltersError {
  errorCodes: [FiltersErrorCode!]!
}

enum FiltersErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union FiltersResult = FiltersError | FiltersSuccess

type FiltersSuccess {
  filters: [Filter!]!
}

type FolderPoliciesError {
  errorCodes: [FolderPoliciesErrorCode!]!
}

enum FolderPoliciesErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union FolderPoliciesResult = FolderPoliciesError | FolderPoliciesSuccess

type FolderPoliciesSuccess {
  policies: [FolderPolicy!]!
}

type FolderPolicy {
  action: FolderPolicyAction!
  afterDays: Int!
  createdAt: Date!
  folder: String!
  id: ID!
  updatedAt: Date!
}

enum FolderPolicyAction {
  ARCHIVE
  DELETE
}

type GenerateApiKeyError {
  errorCodes: [GenerateApiKeyErrorCode!]!
}

enum GenerateApiKeyErrorCode {
  ALREADY_EXISTS
  BAD_REQUEST
  UNAUTHORIZED
}

input GenerateApiKeyInput {
  expiresAt: Date!
  name: String!
  scopes: [String!]
}

union GenerateApiKeyResult = GenerateApiKeyError | GenerateApiKeySuccess

type GenerateApiKeySuccess {
  apiKey: ApiKey!
}

type GetDiscoverFeedArticleError {
  errorCodes: [GetDiscoverFeedArticleErrorCode!]!
}

enum GetDiscoverFeedArticleErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union GetDiscoverFeedArticleResults = GetDiscoverFeedArticleError | GetDiscoverFeedArticleSuccess

type GetDiscoverFeedArticleSuccess {
  discoverArticles: [DiscoverFeedArticle]
  pageInfo: PageInfo!
}

type GetDiscoverTopicError {
  errorCodes: [GetDiscoverTopicErrorCode!]!
}

enum GetDiscoverTopicErrorCode {
  UNAUTHORIZED
}

union GetDiscoverTopicResults = GetDiscoverTopicError | GetDiscoverTopicSuccess

type GetDiscoverTopicSuccess {
  discoverTopics: [DiscoverTopic!]
}

type GetFollowersError {
  errorCodes: [GetFollowersErrorCode!]!
}

enum GetFollowersErrorCode {
  UNAUTHORIZED
}

union GetFollowersResult = GetFollowersError | GetFollowersSuccess

type GetFollowersSuccess {
  followers: [User!]!
}

type GetFollowingError {
  errorCodes: [GetFollowingErrorCode!]!
}

enum GetFollowingErrorCode {
  UNAUTHORIZED
}

union GetFollowingResult = GetFollowingError | GetFollowingSuccess

type GetFollowingSuccess {
  following: [User!]!
}

type GetUserPersonalizationError {
  errorCodes: [GetUserPersonalizationErrorCode!]!
}

enum GetUserPersonalizationErrorCode {
  UNAUTHORIZED
}

union GetUserPersonalizationResult = GetUserPersonalizationError | GetUserPersonalizationSuccess

type GetUserPersonalizationSuccess {
  userPersonalization: UserPersonalization
}

input GoogleLoginInput {
  email: String!
  secret: String!
}

type GoogleSignupError {
  errorCodes: [SignupErrorCode]!
}

input GoogleSignupInput {
  bio: String
  email: String!
  name: String!
  pictureUrl: String!
  secret: String!
  sourceUserId: String!
  username: String!
}

union GoogleSignupResult = GoogleSignupError | GoogleSignupSuccess

type GoogleSignupSuccess {
  me: User!
}

type GroupsError {
  errorCodes: [GroupsErrorCode!]!
}

enum GroupsErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union GroupsResult = GroupsError | GroupsSuccess

type GroupsSuccess {
  groups: [RecommendationGroup!]!
}

type HiddenHomeSectionError {
  errorCodes: [HiddenHomeSectionErrorCode!]!
}

enum HiddenHomeSectionErrorCode {
  BAD_REQUEST
  PENDING
  UNAUTHORIZED
}

union HiddenHomeSectionResult = HiddenHomeSectionError | HiddenHomeSectionSuccess

type HiddenHomeSectionSuccess {
  section: HomeSection
}

type Highlight {
  annotation: String
  color: String
  createdAt: Date!
  createdByMe: Boolean!
  highlightPositionAnchorIndex: Int
  highlightPositionPercent: Float
  html: String
  id: ID!
  labels: [Label!]
  libraryItem: Article!
  patch: String
  prefix: String
  quote: String
  reactions: [Reaction!]!
  replies: [HighlightReply!]!
  representation: RepresentationType!
  sharedAt: Date
  shortId: String!
  suffix: String
  type: HighlightType!
  updatedAt: Date
  user: User!
}

type HighlightEdge {
  cursor: String!
  node: Highlight!
}

type HighlightReply {
  createdAt: Date!
  highlight: Highlight!
  id: ID!
  text: String!
  updatedAt: Date
  user: User!
}

type HighlightStats {
  highlightCount: Int!
}

enum HighlightType {
  HIGHLIGHT
  NOTE
  REDACTION
}

type HighlightsError {
  errorCodes: [HighlightsErrorCode!]!
}

enum HighlightsErrorCode {
  BAD_REQUEST
}

union HighlightsResult = HighlightsError | HighlightsSuccess

type HighlightsSuccess {
  edges: [HighlightEdge!]!
  pageInfo: PageInfo!
}

type HomeEdge {
  cursor: String!
  node: HomeSection!
}

type HomeError {
  errorCodes: [HomeErrorCode!]!
}

enum HomeErrorCode {
  BAD_REQUEST
  PENDING
  UNAUTHORIZED
}

type HomeItem {
  author: String
  broadcastCount: Int
  canArchive: Boolean
  canComment: Boolean
  canDelete: Boolean
  canMove: Boolean
  canSave: Boolean
  canShare: Boolean
  date: Date!
  dir: String
  id: ID!
  likeCount: Int
  previewContent: String
  saveCount: Int
  score: Float
  seen_at: Date
  slug: String
  source: HomeItemSource
  thumbnail: String
  title: String!
  url: String!
  wordCount: Int
}

type HomeItemSource {
  icon: String
  id: ID
  name: String
  type: HomeItemSourceType!
  url: String
}

enum HomeItemSourceType {
  LIBRARY
  NEWSLETTER
  RECOMMENDATION
  RSS
}

union HomeResult = HomeError | HomeSuccess

type HomeSection {
  items: [HomeItem!]!
  layout: String
  thumbnail: String
  title: String
}

type HomeSuccess {
  edges: [HomeEdge!]!
  pageInfo: PageInfo!
}

type ImportFromIntegrationError {
  errorCodes: [ImportFromIntegrationErrorCode!]!
}

enum ImportFromIntegrationErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union ImportFromIntegrationResult = ImportFromIntegrationError | ImportFromIntegrationSuccess

type ImportFromIntegrationSuccess {
  success: Boolean!
}

enum ImportItemState {
  ALL
  ARCHIVED
  UNARCHIVED
  UNREAD
}

type Integration {
  createdAt: Date!
  enabled: Boolean!
  id: ID!
  name: String!
  settings: JSON
  taskName: String
  token: String!
  type: IntegrationType!
  updatedAt: Date
}

type IntegrationError {
  errorCodes: [IntegrationErrorCode!]!
}

enum IntegrationErrorCode {
  NOT_FOUND
}

union IntegrationResult = IntegrationError | IntegrationSuccess

type IntegrationSuccess {
  integration: Integration!
}

enum IntegrationType {
  EXPORT
  IMPORT
}

type IntegrationsError {
  errorCodes: [IntegrationsErrorCode!]!
}

enum IntegrationsErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union IntegrationsResult = IntegrationsError | IntegrationsSuccess

type IntegrationsSuccess {
  integrations: [Integration!]!
}

scalar JSON

type JoinGroupError {
  errorCodes: [JoinGroupErrorCode!]!
}

enum JoinGroupErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union JoinGroupResult = JoinGroupError | JoinGroupSuccess

type JoinGroupSuccess {
  group: RecommendationGroup!
}

type Label {
  color: String!
  createdAt: Date
  description: String
  id: ID!
  internal: Boolean
  name: String!
  position: Int
  source: String
}

type LabelsError {
  errorCodes: [LabelsErrorCode!]!
}

enum LabelsErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union LabelsResult = LabelsError | LabelsSuccess

type LabelsSuccess {
  labels: [Label!]!
}

type LeaveGroupError {
  errorCodes: [LeaveGroupErrorCode!]!
}

enum LeaveGroupErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union LeaveGroupResult = LeaveGroupError | LeaveGroupSuccess

type LeaveGroupSuccess {
  success: Boolean!
}

type Link {
  highlightStats: HighlightStats!
  id: ID!
  page: Page!
  postedByViewer: Boolean!
  readState: ReadState!
  savedAt: Date!
  savedBy: User!
  savedByViewer: Boolean!
  shareInfo: LinkShareInfo!
  shareStats: ShareStats!
  slug: String!
  updatedAt: Date
  url: String!
}

type LinkShareInfo {
  description: String!
  imageUrl: String!
  title: String!
}

type LogOutError {
  errorCodes: [LogOutErrorCode!]!
}

enum LogOutErrorCode {
  LOG_OUT_FAILED
}

union LogOutResult = LogOutError | LogOutSuccess

type LogOutSuccess {
  message: String
}

type LoginError {
  errorCodes: [LoginErrorCode!]!
}

enum LoginErrorCode {
  ACCESS_DENIED
  AUTH_FAILED
  INVALID_CREDENTIALS
  USER_ALREADY_EXISTS
  USER_NOT_FOUND
  WRONG_SOURCE
}

union LoginResult = LoginError | LoginSuccess

type LoginSuccess {
  me: User!
}

type MarkEmailAsItemError {
  errorCodes: [MarkEmailAsItemErrorCode!]!
}

enum MarkEmailAsItemErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union MarkEmailAsItemResult = MarkEmailAsItemError | MarkEmailAsItemSuccess

type MarkEmailAsItemSuccess {
  success: Boolean!
}

type MergeHighlightError {
  errorCodes: [MergeHighlightErrorCode!]!
}

enum MergeHighlightErrorCode {
  ALREADY_EXISTS
  BAD_DATA
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

input MergeHighlightInput {
  annotation: String
  articleId: ID!
  color: String
  highlightPositionAnchorIndex: Int
  highlightPositionPercent: Float
  html: String
  id: ID!
  overlapHighlightIdList: [String!]!
  patch: String!
  prefix: String
  quote: String!
  representation: RepresentationType
  shortId: ID!
  suffix: String
}

union MergeHighlightResult = MergeHighlightError | MergeHighlightSuccess

type MergeHighlightSuccess {
  highlight: Highlight!
  overlapHighlightIdList: [String!]!
}

type MoveFilterError {
  errorCodes: [MoveFilterErrorCode!]!
}

enum MoveFilterErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input MoveFilterInput {
  afterFilterId: ID
  filterId: ID!
}

union MoveFilterResult = MoveFilterError | MoveFilterSuccess

type MoveFilterSuccess {
  filter: Filter!
}

type MoveLabelError {
  errorCodes: [MoveLabelErrorCode!]!
}

enum MoveLabelErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input MoveLabelInput {
  afterLabelId: ID
  labelId: ID!
}

union MoveLabelResult = MoveLabelError | MoveLabelSuccess

type MoveLabelSuccess {
  label: Label!
}

type MoveToFolderError {
  errorCodes: [MoveToFolderErrorCode!]!
}

enum MoveToFolderErrorCode {
  ALREADY_EXISTS
  BAD_REQUEST
  UNAUTHORIZED
}

union MoveToFolderResult = MoveToFolderError | MoveToFolderSuccess

type MoveToFolderSuccess {
  success: Boolean!
}

type Mutation {
  addDiscoverFeed(input: AddDiscoverFeedInput!): AddDiscoverFeedResult!
  addPopularRead(name: String!): AddPopularReadResult!
  bulkAction(action: BulkActionType!, arguments: JSON, async: Boolean, expectedCount: Int, labelIds: [ID!], query: String!): BulkActionResult!
  createArticle(input: CreateArticleInput!): CreateArticleResult!
  createArticleSavingRequest(input: CreateArticleSavingRequestInput!): CreateArticleSavingRequestResult!
  createFolderPolicy(input: CreateFolderPolicyInput!): CreateFolderPolicyResult!
  createGroup(input: CreateGroupInput!): CreateGroupResult!
  createHighlight(input: CreateHighlightInput!): CreateHighlightResult!
  createLabel(input: CreateLabelInput!): CreateLabelResult!
  createNewsletterEmail(input: CreateNewsletterEmailInput): CreateNewsletterEmailResult!
  deleteAccount(userID: ID!): DeleteAccountResult!
  deleteDiscoverArticle(input: DeleteDiscoverArticleInput!): DeleteDiscoverArticleResult!
  deleteDiscoverFeed(input: DeleteDiscoverFeedInput!): DeleteDiscoverFeedResult!
  deleteFilter(id: ID!): DeleteFilterResult!
  deleteFolderPolicy(id: ID!): DeleteFolderPolicyResult!
  deleteHighlight(highlightId: ID!): DeleteHighlightResult!
  deleteIntegration(id: ID!): DeleteIntegrationResult!
  deleteLabel(id: ID!): DeleteLabelResult!
  deleteNewsletterEmail(newsletterEmailId: ID!): DeleteNewsletterEmailResult!
  deleteRule(id: ID!): DeleteRuleResult!
  deleteWebhook(id: ID!): DeleteWebhookResult!
  editDiscoverFeed(input: EditDiscoverFeedInput!): EditDiscoverFeedResult!
  emptyTrash: EmptyTrashResult!
  exportToIntegration(integrationId: ID!): ExportToIntegrationResult!
  fetchContent(id: ID!): FetchContentResult!
  generateApiKey(input: GenerateApiKeyInput!): GenerateApiKeyResult!
  googleLogin(input: GoogleLoginInput!): LoginResult!
  googleSignup(input: GoogleSignupInput!): GoogleSignupResult!
  importFromIntegration(integrationId: ID!): ImportFromIntegrationResult!
  joinGroup(inviteCode: String!): JoinGroupResult!
  leaveGroup(groupId: ID!): LeaveGroupResult!
  logOut: LogOutResult!
  markEmailAsItem(recentEmailId: ID!): MarkEmailAsItemResult!
  mergeHighlight(input: MergeHighlightInput!): MergeHighlightResult!
  moveFilter(input: MoveFilterInput!): MoveFilterResult!
  moveLabel(input: MoveLabelInput!): MoveLabelResult!
  moveToFolder(folder: String!, id: ID!): MoveToFolderResult!
  optInFeature(input: OptInFeatureInput!): OptInFeatureResult!
  recommend(input: RecommendInput!): RecommendResult!
  recommendHighlights(input: RecommendHighlightsInput!): RecommendHighlightsResult!
  refreshHome: RefreshHomeResult!
  replyToEmail(recentEmailId: ID!, reply: AllowedReply!): ReplyToEmailResult!
  reportItem(input: ReportItemInput!): ReportItemResult!
  revokeApiKey(id: ID!): RevokeApiKeyResult!
  saveArticleReadingProgress(input: SaveArticleReadingProgressInput!): SaveArticleReadingProgressResult!
  saveDiscoverArticle(input: SaveDiscoverArticleInput!): SaveDiscoverArticleResult!
  saveFile(input: SaveFileInput!): SaveResult!
  saveFilter(input: SaveFilterInput!): SaveFilterResult!
  savePage(input: SavePageInput!): SaveResult!
  saveUrl(input: SaveUrlInput!): SaveResult!
  setBookmarkArticle(input: SetBookmarkArticleInput!): SetBookmarkArticleResult!
  setDeviceToken(input: SetDeviceTokenInput!): SetDeviceTokenResult!
  setFavoriteArticle(id: ID!): SetFavoriteArticleResult!
  setIntegration(input: SetIntegrationInput!): SetIntegrationResult!
  setLabels(input: SetLabelsInput!): SetLabelsResult!
  setLabelsForHighlight(input: SetLabelsForHighlightInput!): SetLabelsResult!
  setLinkArchived(input: ArchiveLinkInput!): ArchiveLinkResult!
  setRule(input: SetRuleInput!): SetRuleResult!
  setUserPersonalization(input: SetUserPersonalizationInput!): SetUserPersonalizationResult!
  setWebhook(input: SetWebhookInput!): SetWebhookResult!
  subscribe(input: SubscribeInput!): SubscribeResult!
  unsubscribe(name: String!, subscriptionId: ID): UnsubscribeResult!
  updateEmail(input: UpdateEmailInput!): UpdateEmailResult!
  updateFilter(input: UpdateFilterInput!): UpdateFilterResult!
  updateFolderPolicy(input: UpdateFolderPolicyInput!): UpdateFolderPolicyResult!
  updateHighlight(input: UpdateHighlightInput!): UpdateHighlightResult!
  updateLabel(input: UpdateLabelInput!): UpdateLabelResult!
  updateNewsletterEmail(input: UpdateNewsletterEmailInput!): UpdateNewsletterEmailResult!
  updatePage(input: UpdatePageInput!): UpdatePageResult!
  updateSubscription(input: UpdateSubscriptionInput!): UpdateSubscriptionResult!
  updateUser(input: UpdateUserInput!): UpdateUserResult!
  updateUserProfile(input: UpdateUserProfileInput!): UpdateUserProfileResult!
  uploadFileRequest(input: UploadFileRequestInput!): UploadFileRequestResult!
  uploadImportFile(contentType: String!, type: UploadImportFileType!): UploadImportFileResult!
}

type NewsletterEmail {
  address: String!
  confirmationCode: String
  createdAt: Date!
  description: String
  folder: String!
  id: ID!
  name: String
  subscriptionCount: Int!
}

type NewsletterEmailsError {
  errorCodes: [NewsletterEmailsErrorCode!]!
}

enum NewsletterEmailsErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union NewsletterEmailsResult = NewsletterEmailsError | NewsletterEmailsSuccess

type NewsletterEmailsSuccess {
  newsletterEmails: [NewsletterEmail!]!
}

type OptInFeatureError {
  errorCodes: [OptInFeatureErrorCode!]!
}

enum OptInFeatureErrorCode {
  BAD_REQUEST
  INELIGIBLE
  NOT_FOUND
}

input OptInFeatureInput {
  name: String!
}

union OptInFeatureResult = OptInFeatureError | OptInFeatureSuccess

type OptInFeatureSuccess {
  feature: Feature!
}

type Page {
  author: String
  createdAt: Date!
  description: String
  hash: String!
  id: ID!
  image: String!
  originalHtml: String!
  originalUrl: String!
  publishedAt: Date
  readableHtml: String!
  title: String!
  type: PageType!
  updatedAt: Date
  url: String!
}

type PageInfo {
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
  totalCount: Int
}

input PageInfoInput {
  author: String
  canonicalUrl: String
  contentType: String
  description: String
  previewImage: String
  publishedAt: Date
  title: String
}

enum PageType {
  ARTICLE
  BOOK
  FILE
  HIGHLIGHTS
  IMAGE
  PROFILE
  TWEET
  UNKNOWN
  VIDEO
  WEBSITE
}

input ParseResult {
  byline: String
  content: String!
  dir: String
  excerpt: String!
  language: String
  length: Int!
  previewImage: String
  publishedDate: Date
  siteIcon: String
  siteName: String
  textContent: String!
  title: String!
}

input PreparedDocumentInput {
  document: String!
  pageInfo: PageInfoInput!
}

type Profile {
  bio: String
  id: ID!
  pictureUrl: String
  private: Boolean!
  username: String!
}

type Query {
  apiKeys: ApiKeysResult!
  article(format: String, slug: String!, username: String!): ArticleResult!
  articleSavingRequest(id: ID, url: String): ArticleSavingRequestResult!
  deviceTokens: DeviceTokensResult!
  discoverFeeds: DiscoverFeedResult!
  discoverTopics: GetDiscoverTopicResults!
  feeds(input: FeedsInput!): FeedsResult!
  filters: FiltersResult!
  folderPolicies: FolderPoliciesResult!
  getDiscoverFeedArticles(after: String, discoverTopicId: String!, feedId: ID, first: Int): GetDiscoverFeedArticleResults!
  getUserPersonalization: GetUserPersonalizationResult!
  groups: GroupsResult!
  hello: String
  hiddenHomeSection: HiddenHomeSectionResult!
  highlights(after: String, first: Int, query: String): HighlightsResult!
  home(after: String, first: Int): HomeResult!
  integration(name: String!): IntegrationResult!
  integrations: IntegrationsResult!
  labels: LabelsResult!
  me: User
  newsletterEmails: NewsletterEmailsResult!
  recentEmails: RecentEmailsResult!
  recentSearches: RecentSearchesResult!
  rules(enabled: Boolean): RulesResult!
  scanFeeds(input: ScanFeedsInput!): ScanFeedsResult!
  search(after: String, first: Int, format: String, includeContent: Boolean, query: String): SearchResult!
  sendInstallInstructions: SendInstallInstructionsResult!
  subscription(id: ID!): SubscriptionResult!
  subscriptions(sort: SortParams, type: SubscriptionType): SubscriptionsResult!
  typeaheadSearch(first: Int, query: String!): TypeaheadSearchResult!
  updatesSince(after: String, first: Int, folder: String, since: Date!, sort: SortParams): UpdatesSinceResult!
  user(userId: ID, username: String): UserResult!
  users: UsersResult!
  validateUsername(username: String!): Boolean!
  webhook(id: ID!): WebhookResult!
  webhooks: WebhooksResult!
}

type Reaction {
  code: ReactionType!
  createdAt: Date!
  id: ID!
  updatedAt: Date
  user: User!
}

enum ReactionType {
  CRYING
  HEART
  HUSHED
  LIKE
  POUT
  SMILE
}

type ReadState {
  progressAnchorIndex: Int!
  progressPercent: Float!
  reading: Boolean
  readingTime: Int
}

type RecentEmail {
  createdAt: Date!
  from: String!
  html: String
  id: ID!
  reply: String
  replyTo: String
  subject: String!
  text: String!
  to: String!
  type: String!
}

type RecentEmailsError {
  errorCodes: [RecentEmailsErrorCode!]!
}

enum RecentEmailsErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union RecentEmailsResult = RecentEmailsError | RecentEmailsSuccess

type RecentEmailsSuccess {
  recentEmails: [RecentEmail!]!
}

type RecentSearch {
  createdAt: Date!
  id: ID!
  term: String!
}

type RecentSearchesError {
  errorCodes: [RecentSearchesErrorCode!]!
}

enum RecentSearchesErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union RecentSearchesResult = RecentSearchesError | RecentSearchesSuccess

type RecentSearchesSuccess {
  searches: [RecentSearch!]!
}

type RecommendError {
  errorCodes: [RecommendErrorCode!]!
}

enum RecommendErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

type RecommendHighlightsError {
  errorCodes: [RecommendHighlightsErrorCode!]!
}

enum RecommendHighlightsErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input RecommendHighlightsInput {
  groupIds: [ID!]!
  highlightIds: [ID!]!
  note: String
  pageId: ID!
}

union RecommendHighlightsResult = RecommendHighlightsError | RecommendHighlightsSuccess

type RecommendHighlightsSuccess {
  success: Boolean!
}

input RecommendInput {
  groupIds: [ID!]!
  note: String
  pageId: ID!
  recommendedWithHighlights: Boolean
}

union RecommendResult = RecommendError | RecommendSuccess

type RecommendSuccess {
  success: Boolean!
}

type Recommendation {
  id: ID!
  name: String!
  note: String
  recommendedAt: Date!
  user: RecommendingUser
}

type RecommendationGroup {
  admins: [User!]!
  canPost: Boolean!
  canSeeMembers: Boolean!
  createdAt: Date!
  description: String
  id: ID!
  inviteUrl: String!
  members: [User!]!
  name: String!
  topics: [String!]
  updatedAt: Date
}

type RecommendingUser {
  name: String!
  profileImageURL: String
  userId: String!
  username: String!
}

type RefreshHomeError {
  errorCodes: [RefreshHomeErrorCode!]!
}

enum RefreshHomeErrorCode {
  PENDING
}

union RefreshHomeResult = RefreshHomeError | RefreshHomeSuccess

type RefreshHomeSuccess {
  success: Boolean!
}

type Reminder {
  archiveUntil: Boolean!
  id: ID!
  remindAt: Date!
  sendNotification: Boolean!
}

type ReminderError {
  errorCodes: [ReminderErrorCode!]!
}

enum ReminderErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union ReminderResult = ReminderError | ReminderSuccess

type ReminderSuccess {
  reminder: Reminder!
}

type ReplyToEmailError {
  errorCodes: [ReplyToEmailErrorCode!]!
}

enum ReplyToEmailErrorCode {
  UNAUTHORIZED
}

union ReplyToEmailResult = ReplyToEmailError | ReplyToEmailSuccess

type ReplyToEmailSuccess {
  success: Boolean!
}

input ReportItemInput {
  itemUrl: String!
  pageId: ID!
  reportComment: String!
  reportTypes: [ReportType!]!
  sharedBy: ID
}

type ReportItemResult {
  message: String!
}

enum ReportType {
  ABUSIVE
  CONTENT_DISPLAY
  CONTENT_VIOLATION
  SPAM
}

enum RepresentationType {
  CONTENT
  FEED_CONTENT
}

type RevokeApiKeyError {
  errorCodes: [RevokeApiKeyErrorCode!]!
}

enum RevokeApiKeyErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union RevokeApiKeyResult = RevokeApiKeyError | RevokeApiKeySuccess

type RevokeApiKeySuccess {
  apiKey: ApiKey!
}

type Rule {
  actions: [RuleAction!]!
  createdAt: Date!
  enabled: Boolean!
  eventTypes: [RuleEventType!]!
  failedAt: Date
  filter: String!
  id: ID!
  name: String!
  updatedAt: Date
}

type RuleAction {
  params: [String!]!
  type: RuleActionType!
}

input RuleActionInput {
  params: [String!]!
  type: RuleActionType!
}

enum RuleActionType {
  ADD_LABEL
  ARCHIVE
  DELETE
  EXPORT
  MARK_AS_READ
  SEND_NOTIFICATION
  WEBHOOK
}

enum RuleEventType {
  HIGHLIGHT_CREATED
  HIGHLIGHT_UPDATED
  LABEL_CREATED
  PAGE_CREATED
  PAGE_UPDATED
}

type RulesError {
  errorCodes: [RulesErrorCode!]!
}

enum RulesErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union RulesResult = RulesError | RulesSuccess

type RulesSuccess {
  rules: [Rule!]!
}

type SaveArticleReadingProgressError {
  errorCodes: [SaveArticleReadingProgressErrorCode!]!
}

enum SaveArticleReadingProgressErrorCode {
  BAD_DATA
  NOT_FOUND
  UNAUTHORIZED
}

input SaveArticleReadingProgressInput {
  force: Boolean
  id: ID!
  readingProgressAnchorIndex: Int
  readingProgressPercent: Float!
  readingProgressTopPercent: Float
}

union SaveArticleReadingProgressResult = SaveArticleReadingProgressError | SaveArticleReadingProgressSuccess

type SaveArticleReadingProgressSuccess {
  updatedArticle: Article!
}

type SaveDiscoverArticleError {
  errorCodes: [SaveDiscoverArticleErrorCode!]!
}

enum SaveDiscoverArticleErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input SaveDiscoverArticleInput {
  discoverArticleId: ID!
  locale: String
  timezone: String
}

union SaveDiscoverArticleResult = SaveDiscoverArticleError | SaveDiscoverArticleSuccess

type SaveDiscoverArticleSuccess {
  saveId: String!
  url: String!
}

type SaveError {
  errorCodes: [SaveErrorCode!]!
  message: String
}

enum SaveErrorCode {
  EMBEDDED_HIGHLIGHT_FAILED
  UNAUTHORIZED
  UNKNOWN
}

input SaveFileInput {
  clientRequestId: ID!
  folder: String
  labels: [CreateLabelInput!]
  publishedAt: Date
  savedAt: Date
  source: String!
  state: ArticleSavingRequestStatus
  subscription: String
  uploadFileId: ID!
  url: String!
}

type SaveFilterError {
  errorCodes: [SaveFilterErrorCode!]!
}

enum SaveFilterErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input SaveFilterInput {
  category: String
  description: String
  filter: String!
  folder: String
  name: String!
  position: Int
}

union SaveFilterResult = SaveFilterError | SaveFilterSuccess

type SaveFilterSuccess {
  filter: Filter!
}

input SavePageInput {
  clientRequestId: ID!
  folder: String
  labels: [CreateLabelInput!]
  originalContent: String!
  parseResult: ParseResult
  publishedAt: Date
  rssFeedUrl: String
  savedAt: Date
  source: String!
  state: ArticleSavingRequestStatus
  title: String
  url: String!
}

union SaveResult = SaveError | SaveSuccess

type SaveSuccess {
  clientRequestId: ID!
  url: String!
}

input SaveUrlInput {
  clientRequestId: ID!
  folder: String
  labels: [CreateLabelInput!]
  locale: String
  publishedAt: Date
  savedAt: Date
  source: String!
  state: ArticleSavingRequestStatus
  timezone: String
  url: String!
}

type ScanFeedsError {
  errorCodes: [ScanFeedsErrorCode!]!
}

enum ScanFeedsErrorCode {
  BAD_REQUEST
}

input ScanFeedsInput {
  opml: String
  url: String
}

union ScanFeedsResult = ScanFeedsError | ScanFeedsSuccess

type ScanFeedsSuccess {
  feeds: [Feed!]!
}

type SearchError {
  errorCodes: [SearchErrorCode!]!
}

enum SearchErrorCode {
  QUERY_TOO_LONG
  UNAUTHORIZED
}

type SearchItem {
  aiSummary: String
  annotation: String
  archivedAt: Date
  author: String
  color: String
  content: String
  contentReader: ContentReader!
  createdAt: Date!
  description: String
  directionality: DirectionalityType
  feedContent: String
  folder: String!
  format: String
  highlights: [Highlight!]
  id: ID!
  image: String
  isArchived: Boolean!
  labels: [Label!]
  language: String
  links: JSON
  originalArticleUrl: String
  ownedByViewer: Boolean
  pageId: ID
  pageType: PageType!
  previewContentType: String
  publishedAt: Date
  quote: String
  readAt: Date
  readingProgressAnchorIndex: Int!
  readingProgressPercent: Float!
  readingProgressTopPercent: Float
  recommendations: [Recommendation!]
  savedAt: Date!
  score: Float
  seenAt: Date
  shortId: String
  siteIcon: String
  siteName: String
  slug: String!
  state: ArticleSavingRequestStatus
  subscription: String
  title: String!
  unsubHttpUrl: String
  unsubMailTo: String
  updatedAt: Date
  uploadFileId: ID
  url: String!
  wordsCount: Int
}

type SearchItemEdge {
  cursor: String!
  node: SearchItem!
}

union SearchResult = SearchError | SearchSuccess

type SearchSuccess {
  edges: [SearchItemEdge!]!
  pageInfo: PageInfo!
}

type SendInstallInstructionsError {
  errorCodes: [SendInstallInstructionsErrorCode!]!
}

enum SendInstallInstructionsErrorCode {
  BAD_REQUEST
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

union SendInstallInstructionsResult = SendInstallInstructionsError | SendInstallInstructionsSuccess

type SendInstallInstructionsSuccess {
  sent: Boolean!
}

type SetBookmarkArticleError {
  errorCodes: [SetBookmarkArticleErrorCode!]!
}

enum SetBookmarkArticleErrorCode {
  BOOKMARK_EXISTS
  NOT_FOUND
}

input SetBookmarkArticleInput {
  articleID: ID!
  bookmark: Boolean!
}

union SetBookmarkArticleResult = SetBookmarkArticleError | SetBookmarkArticleSuccess

type SetBookmarkArticleSuccess {
  bookmarkedArticle: Article!
}

type SetDeviceTokenError {
  errorCodes: [SetDeviceTokenErrorCode!]!
}

enum SetDeviceTokenErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input SetDeviceTokenInput {
  id: ID
  token: String
}

union SetDeviceTokenResult = SetDeviceTokenError | SetDeviceTokenSuccess

type SetDeviceTokenSuccess {
  deviceToken: DeviceToken!
}

type SetFavoriteArticleError {
  errorCodes: [SetFavoriteArticleErrorCode!]!
}

enum SetFavoriteArticleErrorCode {
  ALREADY_EXISTS
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

union SetFavoriteArticleResult = SetFavoriteArticleError | SetFavoriteArticleSuccess

type SetFavoriteArticleSuccess {
  success: Boolean!
}

type SetFollowError {
  errorCodes: [SetFollowErrorCode!]!
}

enum SetFollowErrorCode {
  NOT_FOUND
  UNAUTHORIZED
}

input SetFollowInput {
  follow: Boolean!
  userId: ID!
}

union SetFollowResult = SetFollowError | SetFollowSuccess

type SetFollowSuccess {
  updatedUser: User!
}

type SetIntegrationError {
  errorCodes: [SetIntegrationErrorCode!]!
}

enum SetIntegrationErrorCode {
  ALREADY_EXISTS
  BAD_REQUEST
  INVALID_TOKEN
  NOT_FOUND
  UNAUTHORIZED
}

input SetIntegrationInput {
  enabled: Boolean!
  id: ID
  importItemState: ImportItemState
  name: String!
  settings: JSON
  syncedAt: Date
  taskName: String
  token: String!
  type: IntegrationType
}

union SetIntegrationResult = SetIntegrationError | SetIntegrationSuccess

type SetIntegrationSuccess {
  integration: Integration!
}

type SetLabelsError {
  errorCodes: [SetLabelsErrorCode!]!
}

enum SetLabelsErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input SetLabelsForHighlightInput {
  highlightId: ID!
  labelIds: [ID!]
  labels: [CreateLabelInput!]
}

input SetLabelsInput {
  labelIds: [ID!]
  labels: [CreateLabelInput!]
  pageId: ID!
  source: String
}

union SetLabelsResult = SetLabelsError | SetLabelsSuccess

type SetLabelsSuccess {
  labels: [Label!]!
}

type SetRuleError {
  errorCodes: [SetRuleErrorCode!]!
}

enum SetRuleErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input SetRuleInput {
  actions: [RuleActionInput!]!
  description: String
  enabled: Boolean!
  eventTypes: [RuleEventType!]!
  filter: String!
  id: ID
  name: String!
}

union SetRuleResult = SetRuleError | SetRuleSuccess

type SetRuleSuccess {
  rule: Rule!
}

type SetShareArticleError {
  errorCodes: [SetShareArticleErrorCode!]!
}

enum SetShareArticleErrorCode {
  NOT_FOUND
  UNAUTHORIZED
}

input SetShareArticleInput {
  articleID: ID!
  share: Boolean!
  sharedComment: String
  sharedWithHighlights: Boolean
}

union SetShareArticleResult = SetShareArticleError | SetShareArticleSuccess

type SetShareArticleSuccess {
  updatedArticle: Article!
  updatedFeedArticle: FeedArticle
  updatedFeedArticleId: String
}

type SetShareHighlightError {
  errorCodes: [SetShareHighlightErrorCode!]!
}

enum SetShareHighlightErrorCode {
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

input SetShareHighlightInput {
  id: ID!
  share: Boolean!
}

union SetShareHighlightResult = SetShareHighlightError | SetShareHighlightSuccess

type SetShareHighlightSuccess {
  highlight: Highlight!
}

type SetUserPersonalizationError {
  errorCodes: [SetUserPersonalizationErrorCode!]!
}

enum SetUserPersonalizationErrorCode {
  NOT_FOUND
  UNAUTHORIZED
}

input SetUserPersonalizationInput {
  digestConfig: DigestConfigInput
  fields: JSON
  fontFamily: String
  fontSize: Int
  libraryLayoutType: String
  librarySortOrder: SortOrder
  margin: Int
  speechRate: String
  speechSecondaryVoice: String
  speechVoice: String
  speechVolume: String
  theme: String
}

union SetUserPersonalizationResult = SetUserPersonalizationError | SetUserPersonalizationSuccess

type SetUserPersonalizationSuccess {
  updatedUserPersonalization: UserPersonalization!
}

type SetWebhookError {
  errorCodes: [SetWebhookErrorCode!]!
}

enum SetWebhookErrorCode {
  ALREADY_EXISTS
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input SetWebhookInput {
  contentType: String
  enabled: Boolean
  eventTypes: [WebhookEvent!]!
  id: ID
  method: String
  url: String!
}

union SetWebhookResult = SetWebhookError | SetWebhookSuccess

type SetWebhookSuccess {
  webhook: Webhook!
}

type ShareStats {
  readDuration: Int!
  saveCount: Int!
  viewCount: Int!
}

type SharedArticleError {
  errorCodes: [SharedArticleErrorCode!]!
}

enum SharedArticleErrorCode {
  NOT_FOUND
}

union SharedArticleResult = SharedArticleError | SharedArticleSuccess

type SharedArticleSuccess {
  article: Article!
}

enum SignupErrorCode {
  ACCESS_DENIED
  EXPIRED_TOKEN
  GOOGLE_AUTH_ERROR
  INVALID_EMAIL
  INVALID_PASSWORD
  INVALID_USERNAME
  UNKNOWN
  USER_EXISTS
}

enum SortBy {
  PUBLISHED_AT
  SAVED_AT
  SCORE
  UPDATED_TIME
}

enum SortOrder {
  ASCENDING
  DESCENDING
}

input SortParams {
  by: SortBy!
  order: SortOrder
}

type SubscribeError {
  errorCodes: [SubscribeErrorCode!]!
}

enum SubscribeErrorCode {
  ALREADY_SUBSCRIBED
  BAD_REQUEST
  EXCEEDED_MAX_SUBSCRIPTIONS
  NOT_FOUND
  UNAUTHORIZED
}

input SubscribeInput {
  autoAddToLibrary: Boolean
  fetchContent: Boolean
  fetchContentType: FetchContentType
  folder: String
  isPrivate: Boolean
  subscriptionType: SubscriptionType
  url: String!
}

union SubscribeResult = SubscribeError | SubscribeSuccess

type SubscribeSuccess {
  subscriptions: [Subscription!]!
}

type Subscription {
  autoAddToLibrary: Boolean
  count: Int!
  createdAt: Date!
  description: String
  failedAt: Date
  fetchContent: Boolean!
  fetchContentType: FetchContentType!
  folder: String!
  icon: String
  id: ID!
  isPrivate: Boolean
  lastFetchedAt: Date
  mostRecentItemDate: Date
  name: String!
  newsletterEmail: String
  refreshedAt: Date
  status: SubscriptionStatus!
  type: SubscriptionType!
  unsubscribeHttpUrl: String
  unsubscribeMailTo: String
  updatedAt: Date
  url: String
}

type SubscriptionError {
  errorCodes: [ErrorCode!]!
}

union SubscriptionResult = SubscriptionError | SubscriptionSuccess

type SubscriptionRootType {
  hello: String
}

enum SubscriptionStatus {
  ACTIVE
  DELETED
  UNSUBSCRIBED
}

type SubscriptionSuccess {
  subscription: Subscription!
}

enum SubscriptionType {
  NEWSLETTER
  RSS
}

type SubscriptionsError {
  errorCodes: [SubscriptionsErrorCode!]!
}

enum SubscriptionsErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union SubscriptionsResult = SubscriptionsError | SubscriptionsSuccess

type SubscriptionsSuccess {
  subscriptions: [Subscription!]!
}

type SyncUpdatedItemEdge {
  cursor: String!
  itemID: ID!
  node: SearchItem
  updateReason: UpdateReason!
}

type Task {
  cancellable: Boolean
  createdAt: Date!
  failedReason: String
  id: ID!
  name: String!
  progress: Float
  runningTime: Int
  state: TaskState!
}

enum TaskState {
  CANCELLED
  FAILED
  PENDING
  RUNNING
  SUCCEEDED
}

type TypeaheadSearchError {
  errorCodes: [TypeaheadSearchErrorCode!]!
}

enum TypeaheadSearchErrorCode {
  UNAUTHORIZED
}

type TypeaheadSearchItem {
  contentReader: ContentReader!
  id: ID!
  siteName: String
  slug: String!
  title: String!
}

union TypeaheadSearchResult = TypeaheadSearchError | TypeaheadSearchSuccess

type TypeaheadSearchSuccess {
  items: [TypeaheadSearchItem!]!
}

type UnsubscribeError {
  errorCodes: [UnsubscribeErrorCode!]!
}

enum UnsubscribeErrorCode {
  ALREADY_UNSUBSCRIBED
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
  UNSUBSCRIBE_METHOD_NOT_FOUND
}

union UnsubscribeResult = UnsubscribeError | UnsubscribeSuccess

type UnsubscribeSuccess {
  subscription: Subscription!
}

type UpdateEmailError {
  errorCodes: [UpdateEmailErrorCode!]!
}

enum UpdateEmailErrorCode {
  BAD_REQUEST
  EMAIL_ALREADY_EXISTS
  UNAUTHORIZED
}

input UpdateEmailInput {
  email: String!
}

union UpdateEmailResult = UpdateEmailError | UpdateEmailSuccess

type UpdateEmailSuccess {
  email: String!
  verificationEmailSent: Boolean
}

type UpdateFilterError {
  errorCodes: [UpdateFilterErrorCode!]!
}

enum UpdateFilterErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input UpdateFilterInput {
  category: String
  description: String
  filter: String
  folder: String
  id: String!
  name: String
  position: Int
  visible: Boolean
}

union UpdateFilterResult = UpdateFilterError | UpdateFilterSuccess

type UpdateFilterSuccess {
  filter: Filter!
}

type UpdateFolderPolicyError {
  errorCodes: [UpdateFolderPolicyErrorCode!]!
}

enum UpdateFolderPolicyErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

input UpdateFolderPolicyInput {
  action: FolderPolicyAction
  afterDays: Int
  id: ID!
}

union UpdateFolderPolicyResult = UpdateFolderPolicyError | UpdateFolderPolicySuccess

type UpdateFolderPolicySuccess {
  policy: FolderPolicy!
}

type UpdateHighlightError {
  errorCodes: [UpdateHighlightErrorCode!]!
}

enum UpdateHighlightErrorCode {
  BAD_DATA
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

input UpdateHighlightInput {
  annotation: String
  color: String
  highlightId: ID!
  html: String
  quote: String
  sharedAt: Date
}

type UpdateHighlightReplyError {
  errorCodes: [UpdateHighlightReplyErrorCode!]!
}

enum UpdateHighlightReplyErrorCode {
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

input UpdateHighlightReplyInput {
  highlightReplyId: ID!
  text: String!
}

union UpdateHighlightReplyResult = UpdateHighlightReplyError | UpdateHighlightReplySuccess

type UpdateHighlightReplySuccess {
  highlightReply: HighlightReply!
}

union UpdateHighlightResult = UpdateHighlightError | UpdateHighlightSuccess

type UpdateHighlightSuccess {
  highlight: Highlight!
}

type UpdateLabelError {
  errorCodes: [UpdateLabelErrorCode!]!
}

enum UpdateLabelErrorCode {
  BAD_REQUEST
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
}

input UpdateLabelInput {
  color: String!
  description: String
  labelId: ID!
  name: String!
}

union UpdateLabelResult = UpdateLabelError | UpdateLabelSuccess

type UpdateLabelSuccess {
  label: Label!
}

type UpdateLinkShareInfoError {
  errorCodes: [UpdateLinkShareInfoErrorCode!]!
}

enum UpdateLinkShareInfoErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

input UpdateLinkShareInfoInput {
  description: String!
  linkId: ID!
  title: String!
}

union UpdateLinkShareInfoResult = UpdateLinkShareInfoError | UpdateLinkShareInfoSuccess

type UpdateLinkShareInfoSuccess {
  message: String!
}

type UpdateNewsletterEmailError {
  errorCodes: [UpdateNewsletterEmailErrorCode!]!
}

enum UpdateNewsletterEmailErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

input UpdateNewsletterEmailInput {
  description: String
  folder: String
  id: ID!
  name: String
}

union UpdateNewsletterEmailResult = UpdateNewsletterEmailError | UpdateNewsletterEmailSuccess

type UpdateNewsletterEmailSuccess {
  newsletterEmail: NewsletterEmail!
}

type UpdatePageError {
  errorCodes: [UpdatePageErrorCode!]!
}

enum UpdatePageErrorCode {
  BAD_REQUEST
  FORBIDDEN
  NOT_FOUND
  UNAUTHORIZED
  UPDATE_FAILED
}

input UpdatePageInput {
  byline: String
  description: String
  pageId: ID!
  previewImage: String
  publishedAt: Date
  savedAt: Date
  state: ArticleSavingRequestStatus
  title: String
}

union UpdatePageResult = UpdatePageError | UpdatePageSuccess

type UpdatePageSuccess {
  updatedPage: Article!
}

enum UpdateReason {
  CREATED
  DELETED
  UPDATED
}

type UpdateReminderError {
  errorCodes: [UpdateReminderErrorCode!]!
}

enum UpdateReminderErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input UpdateReminderInput {
  archiveUntil: Boolean!
  id: ID!
  remindAt: Date!
  sendNotification: Boolean!
}

union UpdateReminderResult = UpdateReminderError | UpdateReminderSuccess

type UpdateReminderSuccess {
  reminder: Reminder!
}

type UpdateSharedCommentError {
  errorCodes: [UpdateSharedCommentErrorCode!]!
}

enum UpdateSharedCommentErrorCode {
  NOT_FOUND
  UNAUTHORIZED
}

input UpdateSharedCommentInput {
  articleID: ID!
  sharedComment: String!
}

union UpdateSharedCommentResult = UpdateSharedCommentError | UpdateSharedCommentSuccess

type UpdateSharedCommentSuccess {
  articleID: ID!
  sharedComment: String!
}

type UpdateSubscriptionError {
  errorCodes: [UpdateSubscriptionErrorCode!]!
}

enum UpdateSubscriptionErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

input UpdateSubscriptionInput {
  autoAddToLibrary: Boolean
  description: String
  failedAt: Date
  fetchContent: Boolean
  fetchContentType: FetchContentType
  folder: String
  id: ID!
  isPrivate: Boolean
  lastFetchedChecksum: String
  mostRecentItemDate: Date
  name: String
  refreshedAt: Date
  scheduledAt: Date
  status: SubscriptionStatus
}

union UpdateSubscriptionResult = UpdateSubscriptionError | UpdateSubscriptionSuccess

type UpdateSubscriptionSuccess {
  subscription: Subscription!
}

type UpdateUserError {
  errorCodes: [UpdateUserErrorCode!]!
}

enum UpdateUserErrorCode {
  BIO_TOO_LONG
  EMPTY_NAME
  UNAUTHORIZED
  USER_NOT_FOUND
}

input UpdateUserInput {
  bio: String
  name: String!
}

type UpdateUserProfileError {
  errorCodes: [UpdateUserProfileErrorCode!]!
}

enum UpdateUserProfileErrorCode {
  BAD_DATA
  BAD_USERNAME
  FORBIDDEN
  UNAUTHORIZED
  USERNAME_EXISTS
}

input UpdateUserProfileInput {
  bio: String
  pictureUrl: String
  userId: ID!
  username: String
}

union UpdateUserProfileResult = UpdateUserProfileError | UpdateUserProfileSuccess

type UpdateUserProfileSuccess {
  user: User!
}

union UpdateUserResult = UpdateUserError | UpdateUserSuccess

type UpdateUserSuccess {
  user: User!
}

type UpdatesSinceError {
  errorCodes: [UpdatesSinceErrorCode!]!
}

enum UpdatesSinceErrorCode {
  UNAUTHORIZED
}

union UpdatesSinceResult = UpdatesSinceError | UpdatesSinceSuccess

type UpdatesSinceSuccess {
  edges: [SyncUpdatedItemEdge!]!
  pageInfo: PageInfo!
}

type UploadFileRequestError {
  errorCodes: [UploadFileRequestErrorCode!]!
}

enum UploadFileRequestErrorCode {
  BAD_INPUT
  FAILED_CREATE
  UNAUTHORIZED
}

input UploadFileRequestInput {
  clientRequestId: String
  contentType: String!
  createPageEntry: Boolean
  url: String!
}

union UploadFileRequestResult = UploadFileRequestError | UploadFileRequestSuccess

type UploadFileRequestSuccess {
  createdPageId: String
  id: ID!
  uploadFileId: ID
  uploadSignedUrl: String
}

enum UploadFileStatus {
  COMPLETED
  INITIALIZED
}

type UploadImportFileError {
  errorCodes: [UploadImportFileErrorCode!]!
}

enum UploadImportFileErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
  UPLOAD_DAILY_LIMIT_EXCEEDED
}

union UploadImportFileResult = UploadImportFileError | UploadImportFileSuccess

type UploadImportFileSuccess {
  uploadSignedUrl: String
}

enum UploadImportFileType {
  MATTER
  POCKET
  URL_LIST
}

type User {
  email: String
  featureList: [Feature!]
  features: [String]
  followersCount: Int
  friendsCount: Int
  id: ID!
  intercomHash: String
  isFriend: Boolean @deprecated(reason: "isFriend has been replaced with viewerIsFollowing")
  isFullUser: Boolean
  name: String!
  picture: String
  profile: Profile!
  sharedArticles: [FeedArticle!]!
  sharedArticlesCount: Int
  sharedHighlightsCount: Int
  sharedNotesCount: Int
  source: String
  viewerIsFollowing: Boolean
}

type UserError {
  errorCodes: [UserErrorCode!]!
}

enum UserErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
  USER_NOT_FOUND
}

type UserPersonalization {
  digestConfig: DigestConfig
  fields: JSON
  fontFamily: String
  fontSize: Int
  id: ID
  libraryLayoutType: String
  librarySortOrder: SortOrder
  margin: Int
  speechRate: String
  speechSecondaryVoice: String
  speechVoice: String
  speechVolume: String
  theme: String
}

union UserResult = UserError | UserSuccess

type UserSuccess {
  user: User!
}

type UsersError {
  errorCodes: [UsersErrorCode!]!
}

enum UsersErrorCode {
  UNAUTHORIZED
}

union UsersResult = UsersError | UsersSuccess

type UsersSuccess {
  users: [User!]!
}

type Webhook {
  contentType: String!
  createdAt: Date!
  enabled: Boolean!
  eventTypes: [WebhookEvent!]!
  id: ID!
  method: String!
  updatedAt: Date
  url: String!
}

type WebhookError {
  errorCodes: [WebhookErrorCode!]!
}

enum WebhookErrorCode {
  BAD_REQUEST
  NOT_FOUND
  UNAUTHORIZED
}

enum WebhookEvent {
  HIGHLIGHT_CREATED
  HIGHLIGHT_DELETED
  HIGHLIGHT_UPDATED
  LABEL_CREATED
  LABEL_DELETED
  LABEL_UPDATED
  PAGE_CREATED
  PAGE_DELETED
  PAGE_UPDATED
}

union WebhookResult = WebhookError | WebhookSuccess

type WebhookSuccess {
  webhook: Webhook!
}

type WebhooksError {
  errorCodes: [WebhooksErrorCode!]!
}

enum WebhooksErrorCode {
  BAD_REQUEST
  UNAUTHORIZED
}

union WebhooksResult = WebhooksError | WebhooksSuccess

type WebhooksSuccess {
  webhooks: [Webhook!]!
}