"Defines the type of a workflow structure"
scalar WorkflowStructure

enum FairuUploadType {
  STANDARD
  DOWNLOAD
}

enum FairuSortingDirection {
  ASC
  DESC
}

enum FairuLicenseType {
  STANDARD
  PERIOD
}

enum FairuWorkflowStatus {
  NONE
  TRIGGERED
  PROCESSING
  FAILED
  SUCCESS
}

enum FairuUserStatus {
  CREATED
  PENDING
  ACCEPTED
  DECLINED
}

enum FairuPdfSignatureRequestStatus {
  CREATED
  STARTED
  FAILED
  CANCELED
  DONE
}

enum FairuDiskType {
  FTP
  SFTP
  S3
}

enum FairuWebhookType {
  NONE
  BASIC
  BEARER
}

enum FairuCustomDomainStatus {
  NONE
  CHECKING
  FAILED
  SUCCESS
}

enum FairuGallerySortingField {
  NAME
  CREATED_AT
}

enum FairuWorkflowType {
  COPYRIGHT_SPLITTING
  COPYRIGHT_SPLITTING_SEARCH
  COPYRIGHT_REPLACING
  COPYRIGHT_REPLACING_SEARCH
}

"A date string with format `Y-m-d`, e.g. `2011-05-23`."
scalar Date

"A datetime string with format `Y-m-d H:i:s`, e.g. `2018-05-23 13:43:32`."
scalar DateTime

type DefaultPaginator {
  total: Int
  count: Int
  perPage: Int
  currentPage: Int
  lastPage: Int
  hasMorePages: Boolean
  firstItem: Int
  lastItem: Int
}

type FairuAsset @key(fields: "id") {
  id: ID!
  name: String
  mime: String
  alt: String
  caption(raw: Boolean): String
  description(raw: Boolean): String
  copyrights: [FairuCopyright!]
  copyright_text: String
  licenses: [FairuLicense!]
  blocked: Boolean
  url(width: Int, height: Int, focal_point: String, withStoredFocalPoint: Boolean, quality: Int): String
  width: Int
  height: Int
  original_width: Int
  original_height: Int
  blurhash: String
  focal_point: String
  created_at: String
  updated_at: String
  has_error: Boolean
}

type FairuFolder @key(fields: "id") {
  id: ID!
  name: String
  created_at: DateTime
  updated_at: DateTime
  auto_assign_copyright: Boolean
  copyrights: [FairuCopyright]
}

union FairuEntry = FairuAsset | FairuFolder

type FairuFilePdfSignatureRequest @key(fields: "id") {
  id: ID!
  status: FairuPdfSignatureRequestStatus
  emails: [String]
  file: FairuAsset
  config_url: String
  signature_id: ID
}

type FairuCopyright @key(fields: "id") {
  id: ID!
  name: String
  email: String
  phone: String
  website: String
  active: Boolean
  blocked: Boolean
  created_at: DateTime
  updated_at: DateTime
}

type FairuLicense @key(fields: "id") {
  id: ID!
  name: String
  created_at: DateTime
  updated_at: DateTime
  copyright: FairuCopyright
  interval: Int
  default: Boolean
  active: Boolean
  start: DateTime
  end: DateTime
  replace_license: Boolean
  replace_license_entry: FairuLicense
  replaced_by_license_entry: FairuLicense
  replace_date: DateTime
  type: FairuLicenseType
  days: Int
}

type FairuWorkflow @key(fields: "id") {
  id: ID!
  name: String
  type: FairuWorkflowType!
  active: Boolean
  status: FairuWorkflowStatus!
  has_error: Boolean
  last_at: DateTime
  created_at: DateTime
  updated_at: DateTime
}

type FairuUser @key(fields: "id") {
  id: ID!
  name: String
  email: String
  status: FairuUserStatus
  owner: Boolean
}

type FairuRole @key(fields: "id") {
  id: ID!
  name: String
  permissions: [String!]
  created_at: DateTime
  updated_at: DateTime
}

type FairuDiskStatus @key(fields: "id") {
  id: ID!
  syncing: Boolean
  open: Int
  pending: Int
  synced: Int
  failed: Int
}

type FairuDisk @key(fields: "id") {
  id: ID!
  name: String
  type: FairuDiskType
  path: String
  pattern: String
  delete_at_origin: Boolean
  healthy: Boolean
  syncing: Boolean
  active: Boolean
  credentials: FairuDiskCredentials
  created_at: DateTime
  updated_at: DateTime
  folder: FairuFolder
}

type FairuDiskFTPCredentials {
  ftp_host: String
  ftp_port: Int
  ftp_username: String
  ftp_password: String
}

type FairuDiskS3Credentials {
  key: String
  secret: String
  region: String
  bucket: String
  endpoint: String
  url: String
}

union FairuDiskCredentials = FairuDiskFTPCredentials | FairuDiskS3Credentials

type FairuGallery @key(fields: "id") {
  id: ID!
  name: String
  description(raw: Boolean): String
  date: String
  location: String
  items: [FairuAsset!]
  cover_image: FairuAsset
  sorting_direction: String
  sorting_field: String
  itemsPaginated(page: Int, perPage: Int, orderBy: String, orderDirection: String): FairuGalleryItemList
  copyright_text: String
  copyrights: [FairuCopyright!]
  active: Boolean
  exclude_from_list: Boolean
}

type FairuTenant @key(fields: "id") {
  id: ID!
  name: String
  avatar: FairuAsset
  use_ai: Boolean
  use_ai_onupload: Boolean
  ai_language: String

  "File policy entry - should alternative text for files be enforced"
  force_file_alt: Boolean

  "File policy entry - should a description be enforced"
  force_file_description: Boolean

  "File policy entry - should a caption text be enforced"
  force_file_caption: Boolean

  "File policy entry - should at least one copyright entry be enforced"
  force_filce_copyright: Boolean

  "File policy active?"
  force_file_policy: Boolean

  "Will license use enforced - if this flag is set to true - files without a valid license will be blocked"
  force_license: Boolean

  "Custom domain"
  custom_domain: String

  "If this flag is true we have identified a valid CNAME entry"
  custom_domain_verified: Boolean

  "Status of the custom domain creatoin process"
  custom_domain_status: FairuCustomDomainStatus
  webhook_url: String
  webhook_type: FairuWebhookType
  webhook_authorization: String
  created_at: DateTime
  updated_at: DateTime
  trial_ends_at: DateTime
}

type FairuHealthStatus {
  version: String
  healthy: Boolean
}

type FairuAssetList {
  data: [FairuAsset!]
  paginatorInfo: DefaultPaginator
}

type FairuDiskList {
  data: [FairuDisk!]
  paginatorInfo: DefaultPaginator
}

type FairuFolderList {
  data: [FairuEntry!]
  paginatorInfo: DefaultPaginator
}

type FairuGalleryList {
  data: [FairuGallery!]
  paginatorInfo: DefaultPaginator
}

type FairuGalleryItemList {
  data: [FairuAsset!]
  paginatorInfo: DefaultPaginator
}

type FairuCopyrightList {
  data: [FairuCopyright!]
  paginatorInfo: DefaultPaginator
}

type FairuLicenseList {
  data: [FairuLicense!]
  paginatorInfo: DefaultPaginator
}

type FairuWorkflowList {
  data: [FairuWorkflow!]
  paginatorInfo: DefaultPaginator
}

type FairuUserList {
  data: [FairuUser!]
  paginatorInfo: DefaultPaginator
}

type FairuRoleList {
  data: [FairuRole!]
  paginatorInfo: DefaultPaginator
}

type FairuUploadLink {
  "This will be the ID for the File after uploading"
  id: ID!

  "Use this url to upload the file"
  upload_url: String!

  "Call this url via GET-Request after uploading. This step is required."
  sync_url: String

  "Mime type is returned to help you identify the file type"
  mime: String
}

input FairuFolderFilter {
  onlyAudio: Boolean
  onlyImage: Boolean
  onlyVideo: Boolean
  mimeFilter: String
}

input FairuFileDTO {
  id: ID

  "Enter a name without the file extension - otherwise it will be part of the name"
  name: String

  "Define an alternative text"
  alt: String

  "Add an internal description to the file - html supported"
  description: String

  "This text should be used for text below the asset - html supported"
  caption: String
  active: Boolean
  blocked: Boolean

  "Define an focal point in terms of y-x-zoom eg. 0-10-1"
  focal_point: String

  "Use the copyright ids to pass the list to the file"
  copyrightIds: [ID]

  "Use the ids from license to define a license fo this file"
  licenseIds: [ID]
}

input FairuFolderDTO {
  id: ID
  name: String
  parent: ID
  autoAssignCopyright: Boolean
  inhertiCopyrightAssignment: Boolean
  copyrightIds: [ID]
}

input FairuCopyrightDTO {
  id: ID
  name: String
  email: String
  phone: String
  website: String
  active: Boolean
  blocked: Boolean
}

input FairuLicenseDTO {
  id: ID
  name: String
  copyright_id: ID
  interval: Int
  default: Boolean
  active: Boolean
  start: DateTime
  end: DateTime
  replace_license: Boolean
  replace_license_id: ID
  replace_date: DateTime
  type: FairuLicenseType
  days: Int
}

input FairuGalleryDTO {
  id: ID
  name: String
  description: String
  folder_id: ID
  active: Boolean
  date: DateTime
  exclude_from_list: Boolean
  location: String
  sorting_field: FairuGallerySortingField
  sorting_direction: FairuSortingDirection
}

input FairuDiskDTO {
  id: ID
  name: String
  folder_id: ID
  type: FairuDiskType
  path: String
  pattern: String
  active: Boolean
  delete_at_origin: Boolean
  credentials: FairuDiskCredentialsDTO
}

input FairuDiskCredentialsDTO {
  "For FTP\/SFTP"
  ftp_host: String

  "For FTP\/SFTP"
  ftp_port: Int

  "For FTP\/SFTP"
  ftp_username: String

  "For FTP\/SFTP"
  ftp_password: String

  "For S3"
  key: String

  "For S3"
  secret: String

  "For S3"
  region: String

  "For S3"
  bucket: String

  "For S3"
  endpoint: String

  "For S3"
  url: String
}

input FairuWorkflowDTO {
  id: ID
  type: FairuWorkflowType
  name: String
  active: Boolean
  structure: WorkflowStructure
}

input FairuRoleDTO {
  id: ID
  name: String
  permissions: [String!]
}

input FairuFilePdfSignatureRequestDTO {
  id: ID
  emails: [String]
  file_id: ID
}

"Directions for ordering a list of records."
enum SortOrder {
  "Sort records in ascending order."
  ASC

  "Sort records in descending order."
  DESC
}

"Aggregate functions when ordering by a relation without specifying a column."
enum OrderByRelationAggregateFunction {
  "Amount of items."
  COUNT
}

"Aggregate functions when ordering by a relation that may specify a column."
enum OrderByRelationWithColumnAggregateFunction {
  "Average."
  AVG

  "Minimum."
  MIN

  "Maximum."
  MAX

  "Sum."
  SUM

  "Amount of items."
  COUNT
}

"Allows ordering a list of records."
input OrderByClause {
  "The column that is used for ordering."
  column: String!

  "The direction that is used for ordering."
  order: SortOrder!
}

"Specify if you want to include or exclude trashed results from a query."
enum Trashed {
  "Only return trashed results."
  ONLY

  "Return both trashed and non-trashed results."
  WITH

  "Only return non-trashed results."
  WITHOUT
}

type Query {
  "Simple health check query"
  fairuHealthCheck: FairuHealthStatus

  "Get the information of the current tenant"
  fairuTenant: FairuTenant

  "Get a single file data"
  fairuFile(id: ID!): FairuAsset

  "Search globally in the tenant"
  fairuSearch(page: Int, perPage: Int, search: String!, orderBy: String, orderDirection: FairuSortingDirection): FairuAssetList

  "Get a list of files"
  fairuMultipleFiles(ids: [ID!]): [FairuAsset]

  "Get only the files for a folder"
  fairuFiles(page: Int, perPage: Int, folder: ID): FairuAssetList

  "Get the folder data (files and folder) for a folder"
  fairuFolder(page: Int, perPage: Int, folder: ID, search: String, globalSearch: Boolean, orderBy: String, orderDirection: FairuSortingDirection, onlyFolder: Boolean): FairuFolderList

  "Get single gallery"
  fairuGallery(id: ID!): FairuGallery

  "Get list of galleries that should be displayed"
  fairuGalleries(tenants: [ID!]!, page: Int, perPage: Int, from: String, until: String, search: String, orderBy: String, orderDirection: String): FairuGalleryList

  "Get a list of copyrights for the tenant"
  fairuCopyrights(page: Int, perPage: Int): FairuCopyrightList

  "Get a single copyright entry in the tenant"
  fairuCopyright(id: ID): FairuCopyright

  "Get a list of licenses defined in the tenant"
  fairuLicenses(page: Int, perPage: Int): FairuLicenseList

  "Get a single license information"
  fairuLicense(id: ID): FairuLicense

  "Get a list of defined workflows of the tenant"
  fairuWorkflows(page: Int, perPage: Int): FairuWorkflowList

  "Get a single workflow information"
  fairuWorkflow(id: ID!): FairuWorkflow

  "Get a list of users attached to the tenant"
  fairuUsers(page: Int, perPage: Int): FairuUserList

  "Get the information of a fairu user withing the tenant"
  fairuUser(id: ID!): FairuUser

  "Get a list of roles defined in the tenant"
  fairuRoles(page: Int, perPage: Int): FairuRoleList

  "Get a single role information"
  fairuRole(id: ID!): FairuRole

  "Get a list of sync configuration for the tenant"
  fairuDisks(page: Int, perPage: Int): FairuDiskList

  "Get a single sync disk configuration"
  fairuDisk(id: ID!): FairuDisk

  "Get a single sync disk status"
  fairuDiskStatus(id: ID!): FairuDiskStatus
}

type Mutation {
  createFairuUploadLink(
    "Type of upload you want to create"
    type: FairuUploadType

    "Download url just needed to be added if type is download"
    download_url: String

    "Folder ID"
    folder: ID

    "Filename should be passed to provide a name"
    filename: String!

    "If you want to pass an UUID for your file you can create an UUID and pass it here. This field is not mandatory"
    id: ID

    "Alt text for your asset"
    alt: String

    "Caption text for your asset"
    caption: String

    "Description - this will be is for internal purpose"
    description: String

    "Focal point based on top-left-zoom logic"
    focal_point: String

    "Copyright text - which will be evaluated via our AI service."
    copyright: String
  ): FairuUploadLink

  "Create a gallery"
  createFairuGallery(data: FairuGalleryDTO!): FairuGallery

  "Update a gallery and it's meta data"
  updateFairuGallery(data: FairuGalleryDTO!): FairuGallery

  "Delete a gallery"
  deleteFairuGallery(id: ID!): Boolean

  "Create shareable gallery link"
  createFairuGalleryShareLink(id: ID!): String

  "Create a sync disk entry"
  createFairuDisk(data: FairuDiskDTO!): FairuDisk

  "Update a sync disk and it's meta data"
  updateFairuDisk(data: FairuDiskDTO!): FairuDisk

  "Delete a disk"
  deleteFairuDisk(id: ID!): Boolean

  "Create a role"
  createFairuRole(data: FairuRoleDTO!): FairuRole

  "Update a role"
  updateFairuRole(data: FairuRoleDTO!): FairuRole

  "Delete a role"
  deleteFairuRole(id: ID!): Boolean

  "Invite an user to the tenant"
  inviteFairuUser(email: String!, role: ID!): Boolean

  "Delete an user from the tenant - user will not be deleted by itself"
  deleteFairuUser(id: ID!): Boolean

  "Create a workflow"
  createFairuWorkflow(data: FairuWorkflowDTO!): FairuWorkflow

  "Update a workflow and it's meta data"
  updateFairuWorkflow(data: FairuWorkflowDTO!): FairuWorkflow

  "Delete a workflow"
  deleteFairuWorkflow(id: ID!): Boolean

  "Update meta data for a file"
  updateFairuFile(data: FairuFileDTO!): FairuAsset

  "Delete a single file"
  deleteFairuFile(id: ID!): Boolean

  "Block a file"
  blockFairuFile(id: ID!): Boolean

  "Remove block a file"
  unblockFairuFile(id: ID!): Boolean

  "Move a file"
  moveFairuFile(id: ID!, parent: ID): Boolean

  "Move a folder"
  moveFairuFolder(id: ID!, parent: ID): Boolean

  "Duplicate a file"
  duplicateFairuFile(id: ID!, parent: ID): Boolean

  "Trigger file download process"
  redownloadFairuFile(id: ID!): Boolean

  "Create a folder"
  createFairuFolder(data: FairuFolderDTO!): FairuFolder

  "Update a folder and it's meta data"
  updateFairuFolder(data: FairuFolderDTO!): FairuFolder

  "Delete a single folder"
  deleteFairuFolder(id: ID!): Boolean

  "Create a ftp connectoin to the folder"
  createFairuFolderFTP(id: ID!): FairuDisk

  "Create a copyright"
  createFairuCopyright(data: FairuCopyrightDTO!): FairuCopyright

  "Update a copyright"
  updateFairuCopyright(data: FairuCopyrightDTO!): FairuCopyright

  "Delete a copyright entry"
  deleteFairuCopyright(id: ID!, deleteAssets: Boolean, deleteLicenses: Boolean): Boolean

  "Create a license"
  createFairuLicense(data: FairuLicenseDTO!): FairuLicense

  "Update a license"
  updateFairuLicense(data: FairuLicenseDTO!): FairuLicense

  "Delete a license entry"
  deleteFairuLicense(id: ID!, deleteAssets: Boolean): Boolean

  "Create a pdf signatur request"
  createFairuPdfSignatureRequest(data: FairuFilePdfSignatureRequestDTO!): FairuFilePdfSignatureRequest

  "Start a pdf signatur request"
  startFairuPdfSignatureRequest(id: ID!): FairuFilePdfSignatureRequest

  "Cancel a pdf signatur request"
  cancelFairuPdfSignatureRequest(id: ID!): Boolean
}