type ActiveRecording {
  archiveOnStop: Boolean!
  continuous: Boolean!
  "Archive the specified Flight Recording"
  doArchive: ArchivedRecording
  "Delete the specified Flight Recording"
  doDelete: ActiveRecording
  "Updates the metadata labels for an existing Flight Recording."
  doPutMetadata(metadataInput: MetadataLabelsInput): ActiveRecording
  "Stop the specified Flight Recording"
  doStop: ActiveRecording
  "URL for GET request to retrieve the JFR binary file content of this recording"
  downloadUrl: String
  duration: BigInteger!
  id: BigInteger
  maxAge: BigInteger!
  maxSize: BigInteger!
  metadata: Metadata!
  name: String!
  remoteId: BigInteger!
  "URL for GET request to retrieve a JSON formatted Automated Analysis Report of this recording"
  reportUrl: String
  startTime: BigInteger!
  state: RecordingState!
  target: Target!
  toDisk: Boolean!
}

type ActiveRecordings {
  aggregate: RecordingAggregateInfo!
  data: [ActiveRecording]!
}

type AnalysisResult {
  evaluation: Evaluation
  name: String
  score: Float!
  topic: String
}

type Annotations {
  cryostat(
    "Get entry/entries for a certain key/s"
    key: [String]
  ): [Entry_String_String]!
  platform(
    "Get entry/entries for a certain key/s"
    key: [String]
  ): [Entry_String_String]!
}

type ArchivedRecording {
  archivedTime: BigInteger!
  "Delete an archived recording"
  doDelete: ArchivedRecording!
  "Update the metadata associated with an archived recording"
  doPutMetadata(metadataInput: MetadataLabelsInput): ArchivedRecording!
  downloadUrl: String!
  jvmId: String!
  metadata: Metadata!
  name: String!
  reportUrl: String!
  size: BigInteger!
}

type ArchivedRecordings {
  aggregate: RecordingAggregateInfo!
  data: [ArchivedRecording]!
}

type AsyncProfile {
  duration: BigInteger!
  id: String!
  size: BigInteger!
  startTime: BigInteger!
}

type AsyncProfileAggregateInfo {
  "The number of elements in this collection"
  count: BigInteger!
  "The sum of sizes of elements in this collection, or 0 if not applicable"
  size: BigInteger!
}

type AsyncProfiles {
  aggregate: AsyncProfileAggregateInfo!
  data: [AsyncProfile]!
}

type DiscoveryNode {
  children: [DiscoveryNode]
  "Get target nodes that are descendants of this node. That is, get the set of leaf nodes from anywhere below this node's subtree."
  descendantTargets(filter: DiscoveryNodeFilterInput): [DiscoveryNode]
  id: BigInteger
  labels(
    "Get entry/entries for a certain key/s"
    key: [String]
  ): [Entry_String_String]!
  name: String!
  nodeType: String!
  target: Target
}

type Entry_String_AnalysisResult {
  key: String
  value: AnalysisResult
}

type Entry_String_String {
  key: String
  value: String
}

type Evaluation {
  explanation: String
  solution: String
  suggestions: [Suggestion]
  summary: String
}

type HeapDump {
  "Delete a heap dump"
  doDelete: HeapDump!
  "Update the metadata for a heap dump"
  doPutMetadata(metadataInput: MetadataLabelsInput): HeapDump!
  downloadUrl: String!
  heapDumpId: String!
  jvmId: String!
  lastModified: BigInteger!
  metadata: Metadata!
  size: BigInteger!
}

type HeapDumpAggregateInfo {
  "The number of elements in this collection"
  count: BigInteger!
  "The sum of sizes of elements in this collection, or 0 if not applicable"
  size: BigInteger!
}

type HeapDumps {
  aggregate: HeapDumpAggregateInfo!
  data: [HeapDump]!
}

type MBeanMetrics {
  jvmId: String
  memory: MemoryMetrics
  os: OperatingSystemMetrics
  runtime: RuntimeMetrics
  thread: ThreadMetrics
}

type MemoryMetrics {
  freeHeapMemory: BigInteger!
  freeNonHeapMemory: BigInteger!
  heapMemoryUsage: MemoryUtilization
  heapMemoryUsagePercent: Float!
  nonHeapMemoryUsage: MemoryUtilization
  objectPendingFinalizationCount: BigInteger!
  verbose: Boolean!
}

type MemoryUtilization {
  committed: BigInteger!
  init: BigInteger!
  max: BigInteger!
  used: BigInteger!
}

type Metadata {
  labels(
    "Get entry/entries for a certain key/s"
    key: [String]
  ): [Entry_String_String]!
}

"Mutation root"
type Mutation {
  "Archive an existing Flight Recording matching the given filter, on all Targets under the subtrees of the discovery nodes matching the given filter"
  archiveRecording(nodes: DiscoveryNodeFilterInput!, recordings: ActiveRecordingsFilterInput): [ArchivedRecording]
  "Trigger an async profiler request on all Targets under the subtrees of the discovery nodes matching the given filter"
  createAsyncProfile(duration: BigInteger!, events: [String]!, id: String!, nodes: DiscoveryNodeFilterInput!, startTime: BigInteger!): [String]
  "Trigger a heap dump on all Targets under the subtrees of the discovery nodes matching the given filter"
  createHeapDump(nodes: DiscoveryNodeFilterInput!): [String]
  "Start a new Flight Recording on all Targets under the subtrees of the discovery nodes matching the given filter"
  createRecording(nodes: DiscoveryNodeFilterInput!, recording: RecordingSettingsInput!): [ActiveRecording]
  "Create a Flight Recorder Snapshot on all Targets under the subtrees of the discovery nodes matching the given filter"
  createSnapshot(nodes: DiscoveryNodeFilterInput!): [ActiveRecording]
  "Trigger a thread dump on all Targets under the subtrees of the discovery nodes matching the given filter"
  createThreadDump(nodes: DiscoveryNodeFilterInput!): [String]
  "Delete an existing Async Profile matching the given filter, on all Targets under the subtrees of the discovery nodes matching the given filter"
  deleteAsyncProfiles(filter: AsyncProfilerFilterInput, nodes: DiscoveryNodeFilterInput!): [AsyncProfile]
  "Delete an existing Heap Dump matching the given filter, on all Targets under the subtrees of the discovery nodes matching the given filter"
  deleteHeapDump(filter: HeapDumpsFilterInput, nodes: DiscoveryNodeFilterInput!): [HeapDump]
  "Delete an existing Flight Recording matching the given filter, on all Targets under the subtrees of the discovery nodes matching the given filter"
  deleteRecording(nodes: DiscoveryNodeFilterInput!, recordings: ActiveRecordingsFilterInput): [ActiveRecording]
  "Delete an existing Thread Dump matching the given filter, on all Targets under the subtrees of the discovery nodes matching the given filter"
  deleteThreadDump(filter: ThreadDumpsFilterInput, nodes: DiscoveryNodeFilterInput!): [ThreadDump]
  "Stop an existing Flight Recording matching the given filter, on all Targets under the subtrees of the discovery nodes matching the given filter"
  stopRecording(nodes: DiscoveryNodeFilterInput!, recordings: ActiveRecordingsFilterInput): [ActiveRecording]
}

type OperatingSystemMetrics {
  arch: String
  availableProcessors: Int!
  committedVirtualMemorySize: BigInteger!
  freePhysicalMemorySize: BigInteger!
  freeSwapSpaceSize: BigInteger!
  name: String
  processCpuLoad: Float!
  processCpuTime: BigInteger!
  systemCpuLoad: Float!
  systemLoadAverage: Float!
  totalPhysicalMemorySize: BigInteger!
  totalSwapSpaceSize: BigInteger!
  version: String
}

"Query root"
type Query {
  "List archived recordings"
  archivedRecordings(filter: ArchivedRecordingsFilterInput): ArchivedRecordings
  "Get all environment nodes in the discovery tree with optional filtering"
  environmentNodes(filter: DiscoveryNodeFilterInput): [DiscoveryNode]
  "List archived heap dumps"
  heapDumps(filter: HeapDumpsFilterInput): HeapDumps
  "Get the root target discovery node"
  rootNode: DiscoveryNode
  "Get the Target discovery nodes, i.e. the leaf nodes of the discovery tree"
  targetNodes(
    filter: DiscoveryNodeFilterInput,
    "Query historical targets from audit log. This is more expensive and should only be used when historical data is needed."
    useAuditLog: Boolean = false
  ): [DiscoveryNode]
  "List archived thread dumps"
  threadDumps(filter: ThreadDumpsFilterInput): ThreadDumps
  "List archived unified logs"
  unifiedLogs(filter: UnifiedLogsFilterInput): UnifiedLogs
}

type RecordingAggregateInfo {
  "The number of elements in this collection"
  count: BigInteger!
  "The sum of sizes of elements in this collection, or 0 if not applicable"
  size: BigInteger!
}

type Recordings {
  "List and optionally filter active recordings belonging to a Target"
  active(filter: ActiveRecordingsFilterInput): ActiveRecordings
  "List and optionally filter archived recordings belonging to a Target"
  archived(filter: ArchivedRecordingsFilterInput): ArchivedRecordings
}

type Report {
  aggregate: ReportAggregateInfo!
  data(
    "Get entry/entries for a certain key/s"
    key: [String]
  ): [Entry_String_AnalysisResult]!
  lastUpdated: BigInteger!
}

type ReportAggregateInfo {
  "The number of elements in this collection"
  count: BigInteger!
  "The maximum value in this collection"
  max: Float!
}

type RuntimeMetrics {
  bootClassPath: String
  bootClassPathSupported: Boolean!
  classPath: String
  inputArguments: [String]
  libraryPath: String
  managementSpecVersion: String
  name: String
  specName: String
  specVendor: String
  specVersion: String
  startTime: BigInteger!
  systemProperties(
    "Get entry/entries for a certain key/s"
    key: [String]
  ): [Entry_String_String]
  uptime: BigInteger!
  vmName: String
  vmVendor: String
  vmVersion: String
}

type Suggestion {
  name: String
  setting: String
  value: String
}

type Target {
  "Retrieve a list of active recordings currently available on the target"
  activeRecordings(filter: ActiveRecordingsFilterInput): ActiveRecordings
  agent: Boolean!
  alias: String!
  annotations: Annotations!
  "Retrieve a list of archived recordings belonging to the target"
  archivedRecordings(filter: ArchivedRecordingsFilterInput): ArchivedRecordings
  "Retrieve a list of async profiles belonging to the target"
  asyncProfiles(filter: AsyncProfilerFilterInput): AsyncProfiles
  connectUrl: String!
  "Create a new Flight Recorder Snapshot on the specified Target"
  doSnapshot: ActiveRecording
  "Start a new Flight Recording on the specified Target"
  doStartRecording(recording: RecordingSettingsInput!): ActiveRecording
  "Retrieve a list of heap dumps belonging to the target"
  heapDumps(filter: HeapDumpsFilterInput): HeapDumps
  id: BigInteger
  jvmId: String
  labels(
    "Get entry/entries for a certain key/s"
    key: [String]
  ): [Entry_String_String]!
  "Get live MBean metrics snapshot from the specified Target"
  mbeanMetrics: MBeanMetrics
  "Get the active and archived recordings belonging to this target"
  recordings: Recordings
  """
  Retrieve an automated analysis report from the selected target(s). If there is no report currently
  available then this request will not cause a report to be generated, and instead it will return an empty
  result. Report generation may be an expensive operation, especially if many reports are to be generated at
  once, and should not be triggered by broad GraphQL selections.
  """
  report(filter: ReportFilterInput): Report
  "Retrieve a list of thread dumps belonging to the target"
  threadDumps(filter: ThreadDumpsFilterInput): ThreadDumps
  "Retrieve a list of unified logs belonging to the target"
  unifiedLogs(filter: UnifiedLogsFilterInput): UnifiedLogs
}

type ThreadDump {
  "Delete a thread dump"
  doDelete: ThreadDump!
  "Update the metadata for a thread dump"
  doPutMetadata(metadataInput: MetadataLabelsInput): ThreadDump!
  downloadUrl: String!
  jvmId: String!
  lastModified: BigInteger!
  metadata: Metadata!
  size: BigInteger!
  threadDumpId: String!
}

type ThreadDumpAggregateInfo {
  "The number of elements in this collection"
  count: BigInteger!
  "The sum of sizes of elements in this collection, or 0 if not applicable"
  size: BigInteger!
}

type ThreadDumps {
  aggregate: ThreadDumpAggregateInfo!
  data: [ThreadDump]!
}

type ThreadMetrics {
  allThreadIds: [BigInteger!]
  currentThreadCpuTime: BigInteger!
  currentThreadCpuTimeSupported: Boolean!
  currentThreadUserTime: BigInteger!
  daemonThreadCount: Int!
  objectMonitorUsageSupported: Boolean!
  peakThreadCount: Int!
  synchronizerUsageSupported: Boolean!
  threadContentionMonitoringEnabled: Boolean!
  threadContentionMonitoringSupported: Boolean!
  threadCount: Int!
  threadCpuTimeEnabled: Boolean!
  threadCpuTimeSupported: Boolean!
  totalStartedThreadCount: BigInteger!
}

type UnifiedLog {
  "Delete a unified log"
  doDelete: UnifiedLog!
  downloadUrl: String!
  jvmId: String!
  lastModified: BigInteger!
  metadata: Metadata!
  size: BigInteger!
  unifiedLogId: String!
}

type UnifiedLogAggregateInfo {
  "The number of elements in this collection"
  count: BigInteger!
  "The sum of sizes of elements in this collection, or 0 if not applicable"
  size: BigInteger!
}

type UnifiedLogs {
  aggregate: UnifiedLogAggregateInfo!
  data: [UnifiedLog]!
}

"Running state of an active Flight Recording"
enum RecordingState {
  CLOSED
  DELAYED
  NEW
  RUNNING
  STOPPED
}

input ActiveRecordingsFilterInput {
  continuous: Boolean
  durationMsGreaterThanEqual: BigInteger
  durationMsLessThanEqual: BigInteger
  labels: [String]
  name: String
  names: [String]
  startTimeMsAfterEqual: BigInteger
  startTimeMsBeforeEqual: BigInteger
  state: RecordingState
  toDisk: Boolean
}

input ArchivedRecordingsFilterInput {
  archivedTimeAfterEqual: BigInteger
  archivedTimeBeforeEqual: BigInteger
  labels: [String]
  name: String
  names: [String]
  sizeBytesGreaterThanEqual: BigInteger
  sizeBytesLessThanEqual: BigInteger
  sourceTarget: String
}

input AsyncProfilerFilterInput {
  name: String
  names: [String]
  sizeBytesGreaterThanEqual: BigInteger
  sizeBytesLessThanEqual: BigInteger
}

input DiscoveryNodeFilterInput {
  alias: String
  aliases: [String]
  annotations: [String]
  id: BigInteger
  ids: [BigInteger]
  jvmId: String
  jvmIds: [String]
  labels: [String]
  name: String
  names: [String]
  nodeTypes: [String]
  targetId: BigInteger
  targetIds: [BigInteger]
}

input Entry_String_StringInput {
  key: String
  value: String
}

input HeapDumpsFilterInput {
  archivedTimeAfterEqual: BigInteger
  archivedTimeBeforeEqual: BigInteger
  labels: [String]
  name: String
  names: [String]
  sizeBytesGreaterThanEqual: BigInteger
  sizeBytesLessThanEqual: BigInteger
  sourceTarget: String
}

input MetadataLabelsInput {
  labels: [Entry_String_StringInput]
}

input RecordingMetadataInput {
  labels: [Entry_String_StringInput]
}

input RecordingSettingsInput {
  archiveOnStop: Boolean
  continuous: Boolean
  duration: BigInteger
  maxAge: BigInteger
  maxSize: BigInteger
  metadata: RecordingMetadataInput
  name: String!
  replace: String
  template: String!
  templateType: String!
  toDisk: Boolean
}

input ReportFilterInput {
  id: String
  ids: [String]
  notId: String
  notIds: [String]
  notTopic: String
  notTopics: [String]
  topic: String
  topics: [String]
}

input ThreadDumpsFilterInput {
  archivedTimeAfterEqual: BigInteger
  archivedTimeBeforeEqual: BigInteger
  labels: [String]
  name: String
  names: [String]
  sizeBytesGreaterThanEqual: BigInteger
  sizeBytesLessThanEqual: BigInteger
  sourceTarget: String
}

input UnifiedLogsFilterInput {
  archivedTimeAfterEqual: BigInteger
  archivedTimeBeforeEqual: BigInteger
  labels: [String]
  name: String
  names: [String]
  sizeBytesGreaterThanEqual: BigInteger
  sizeBytesLessThanEqual: BigInteger
  sourceTarget: String
}