tstor/ui/lib/api/schema.graphql

directive @oneOf on INPUT_OBJECT | FIELD_DEFINITION
directive @resolver on INPUT_FIELD_DEFINITION | FIELD_DEFINITION
directive @stream on FIELD_DEFINITION
type ArchiveFS implements Dir & FsEntry {
	name: String!
	entries: [FsEntry!]! @resolver
	size: Int!
}
input BooleanFilter @oneOf {
	eq: Boolean
}
type CleanupResponse {
	count: Int!
	list: [String!]!
}
scalar DateTime
input DateTimeFilter @oneOf {
	eq: DateTime
	gt: DateTime
	lt: DateTime
	gte: DateTime
	lte: DateTime
}
interface Dir implements FsEntry {
	name: String!
	entries: [FsEntry!]!
}
type DownloadTorrentResponse {
	task: Task
}
interface File implements FsEntry {
	name: String!
	size: Int!
}
interface FsEntry {
	name: String!
}
input IntFilter @oneOf {
	eq: Int
	gt: Int
	lt: Int
	gte: Int
	lte: Int
	in: [Int!]
}
type Mutation {
	torrentDaemon: TorrentDaemonMutation @resolver
	qbitTorrentDaemon: QBitTorrentDaemonMutation @resolver
	uploadFile(dir: String!, file: Upload!): Boolean!
	dedupeStorage: Int!
}
input Pagination {
	offset: Int!
	limit: Int!
}
interface Progress {
	current: Int!
	total: Int!
}
type QBitCleanupResponse {
	count: Int!
	hashes: [String!]!
}
type QBitCleanupUnregistredResponse {
	count: Int!
	hashes: [String!]!
}
input QBitTorrentDaemonFilter {
	multipleSources: Boolean
}
type QBitTorrentDaemonMutation {
	cleanup(run: Boolean!): QBitCleanupResponse! @resolver
	cleanupUnregistred(run: Boolean!): QBitCleanupUnregistredResponse! @resolver
}
type QBitTorrentDaemonQuery {
	torrents(filter: QBitTorrentDaemonFilter): [QTorrent!]! @resolver
}
type QTorrent {
	name: String!
	hash: String!
	sourceFiles: [String!]! @resolver
}
type Query {
	torrentDaemon: TorrentDaemonQuery @resolver
	qbitTorrentDaemon: QBitTorrentDaemonQuery @resolver
	fsEntry(path: String!): FsEntry
}
type ResolverFS implements Dir & FsEntry {
	name: String!
	entries: [FsEntry!]! @resolver
}
type Schema {
	query: Query
	mutation: Mutation
}
type SimpleDir implements Dir & FsEntry {
	name: String!
	entries: [FsEntry!]! @resolver
}
type SimpleFile implements File & FsEntry {
	name: String!
	size: Int!
}
input StringFilter @oneOf {
	eq: String
	substr: String
	in: [String!]
}
type Subscription {
	taskProgress(taskID: ID!): Progress
	torrentDownloadUpdates: TorrentProgress
}
type Task {
	id: ID!
}
type Torrent {
	name: String! @resolver
	infohash: String!
	bytesCompleted: Int!
	torrentFilePath: String!
	bytesMissing: Int!
	priority: TorrentPriority!
	files: [TorrentFile!]! @resolver
	excludedFiles: [TorrentFile!]! @resolver
	peers: [TorrentPeer!]! @resolver
}
type TorrentClientStats {
	bytesWritten: Int!
	bytesWrittenData: Int!
	bytesRead: Int!
	bytesReadData: Int!
	bytesReadUsefulData: Int!
	bytesReadUsefulIntendedData: Int!
	chunksWritten: Int!
	chunksRead: Int!
	chunksReadUseful: Int!
	chunksReadWasted: Int!
	metadataChunksRead: Int!
	piecesDirtiedGood: Int!
	piecesDirtiedBad: Int!
}
type TorrentDaemonMutation {
	validateTorrent(filter: TorrentFilter!): Boolean! @resolver
	setTorrentPriority(infohash: String!, file: String, priority: TorrentPriority!): Boolean! @resolver
	cleanup(files: Boolean, dryRun: Boolean!): CleanupResponse! @resolver
}
type TorrentDaemonQuery {
	torrents(filter: TorrentsFilter): [Torrent!]! @resolver
	clientStats: TorrentClientStats! @resolver
	statsHistory(since: DateTime!, infohash: String): [TorrentStats!]! @resolver
}
type TorrentFS implements Dir & FsEntry {
	name: String!
	torrent: Torrent!
	entries: [FsEntry!]! @resolver
}
type TorrentFile {
	filename: String!
	size: Int!
	bytesCompleted: Int!
	priority: TorrentPriority! @resolver
}
type TorrentFileEntry implements File & FsEntry {
	name: String!
	torrent: Torrent!
	size: Int!
}
input TorrentFilter @oneOf {
	everything: Boolean
	infohash: String
}
type TorrentPeer {
	ip: String!
	downloadRate: Float!
	discovery: String!
	port: Int!
	clientName: String!
}
enum TorrentPriority {
	NONE
	NORMAL
	HIGH
	READAHEAD
	NOW
}
input TorrentPriorityFilter @oneOf {
	eq: TorrentPriority
	gt: TorrentPriority
	lt: TorrentPriority
	gte: TorrentPriority
	lte: TorrentPriority
	in: [TorrentPriority!]
}
type TorrentProgress implements Progress {
	torrent: Torrent!
	current: Int!
	total: Int!
}
type TorrentStats {
	timestamp: DateTime!
	downloadedBytes: UInt!
	uploadedBytes: UInt!
	totalPeers: UInt!
	activePeers: UInt!
	connectedSeeders: UInt!
}
input TorrentsFilter {
	infohash: StringFilter
	name: StringFilter
	bytesCompleted: IntFilter
	bytesMissing: IntFilter
	peersCount: IntFilter
	priority: TorrentPriorityFilter
}
scalar UInt
scalar Upload