@remote-app/transmission-client 0.1.4 → 0.22.0

package/dist/schemas.mjs

@@ -0,0 +1,506 @@
+import { n as Priority, r as TorrentStatus, t as Mode } from "./torrent-get-D7xfEr_w.mjs";
+import { z } from "zod";
+
+//#region src/schemas.ts
+const IdentifierIdsSchema = z.union([
+	z.number(),
+	z.array(z.union([z.number(), z.string()])),
+	z.literal("recently-active")
+]);
+const IdentifiersSchema = z.object({ ids: IdentifierIdsSchema.optional() });
+const UnitsSchema = z.object({
+	"speed-units": z.array(z.string()),
+	"speed-bytes": z.number(),
+	"size-units": z.array(z.string()),
+	"size-bytes": z.number(),
+	"memory-units": z.array(z.string()),
+	"memory-bytes": z.number()
+}).passthrough();
+const SessionGetResponseSchema = z.object({
+	"alt-speed-down": z.number().optional(),
+	"alt-speed-enabled": z.boolean().optional(),
+	"alt-speed-time-begin": z.number().optional(),
+	"alt-speed-time-enabled": z.boolean().optional(),
+	"alt-speed-time-end": z.number().optional(),
+	"alt-speed-time-day": z.number().optional(),
+	"alt-speed-up": z.number().optional(),
+	"blocklist-url": z.string().optional(),
+	"blocklist-enabled": z.boolean().optional(),
+	"blocklist-size": z.number().optional(),
+	"cache-size-mb": z.number().optional(),
+	"config-dir": z.string().optional(),
+	"default-trackers": z.string().optional(),
+	"dht-enabled": z.boolean().optional(),
+	"download-dir": z.string().optional(),
+	"download-dir-free-space": z.number().optional(),
+	"download-queue-size": z.number().optional(),
+	"download-queue-enabled": z.boolean().optional(),
+	encryption: z.string().optional(),
+	"idle-seeding-limit": z.number().optional(),
+	"idle-seeding-limit-enabled": z.boolean().optional(),
+	"incomplete-dir": z.string().optional(),
+	"incomplete-dir-enabled": z.boolean().optional(),
+	"lpd-enabled": z.boolean().optional(),
+	"peer-limit-global": z.number().optional(),
+	"peer-limit-per-torrent": z.number().optional(),
+	"pex-enabled": z.boolean().optional(),
+	"peer-port": z.number().optional(),
+	"peer-port-random-on-start": z.boolean().optional(),
+	"port-forwarding-enabled": z.boolean().optional(),
+	"queue-stalled-enabled": z.boolean().optional(),
+	"queue-stalled-minutes": z.number().optional(),
+	"rename-partial-files": z.boolean().optional(),
+	reqq: z.number().optional(),
+	"rpc-version": z.number().optional(),
+	"rpc-version-minimum": z.number().optional(),
+	"rpc-version-semver": z.string().optional(),
+	"script-torrent-added-enabled": z.boolean().optional(),
+	"script-torrent-added-filename": z.string().optional(),
+	"script-torrent-done-filename": z.string().optional(),
+	"script-torrent-done-enabled": z.boolean().optional(),
+	"script-torrent-done-seeding-enabled": z.boolean().optional(),
+	"script-torrent-done-seeding-filename": z.string().optional(),
+	seedRatioLimit: z.number().optional(),
+	seedRatioLimited: z.boolean().optional(),
+	"seed-queue-size": z.number().optional(),
+	"seed-queue-enabled": z.boolean().optional(),
+	"sequential-download": z.boolean().optional(),
+	"session-id": z.string().optional(),
+	"speed-limit-down": z.number().optional(),
+	"speed-limit-down-enabled": z.boolean().optional(),
+	"speed-limit-up": z.number().optional(),
+	"speed-limit-up-enabled": z.boolean().optional(),
+	"start-added-torrents": z.boolean().optional(),
+	"trash-original-torrent-files": z.boolean().optional(),
+	units: UnitsSchema.optional(),
+	"utp-enabled": z.boolean().optional(),
+	version: z.string().optional()
+}).passthrough();
+const SessionGetFieldSchema = z.enum([
+	"alt-speed-down",
+	"alt-speed-enabled",
+	"alt-speed-time-begin",
+	"alt-speed-time-enabled",
+	"alt-speed-time-end",
+	"alt-speed-time-day",
+	"alt-speed-up",
+	"blocklist-url",
+	"blocklist-enabled",
+	"blocklist-size",
+	"cache-size-mb",
+	"config-dir",
+	"default-trackers",
+	"dht-enabled",
+	"download-dir",
+	"download-dir-free-space",
+	"download-queue-size",
+	"download-queue-enabled",
+	"encryption",
+	"idle-seeding-limit",
+	"idle-seeding-limit-enabled",
+	"incomplete-dir",
+	"incomplete-dir-enabled",
+	"lpd-enabled",
+	"peer-limit-global",
+	"peer-limit-per-torrent",
+	"pex-enabled",
+	"peer-port",
+	"peer-port-random-on-start",
+	"port-forwarding-enabled",
+	"queue-stalled-enabled",
+	"queue-stalled-minutes",
+	"rename-partial-files",
+	"reqq",
+	"rpc-version",
+	"rpc-version-minimum",
+	"rpc-version-semver",
+	"script-torrent-added-enabled",
+	"script-torrent-added-filename",
+	"script-torrent-done-filename",
+	"script-torrent-done-enabled",
+	"script-torrent-done-seeding-enabled",
+	"script-torrent-done-seeding-filename",
+	"seedRatioLimit",
+	"seedRatioLimited",
+	"seed-queue-size",
+	"seed-queue-enabled",
+	"sequential-download",
+	"session-id",
+	"speed-limit-down",
+	"speed-limit-down-enabled",
+	"speed-limit-up",
+	"speed-limit-up-enabled",
+	"start-added-torrents",
+	"trash-original-torrent-files",
+	"units",
+	"utp-enabled",
+	"version"
+]);
+const SessionGetRequestSchema = z.object({ fields: z.array(SessionGetFieldSchema).optional() });
+const SessionSetRequestSchema = SessionGetResponseSchema;
+const StatsSchema = z.object({
+	uploadedBytes: z.number(),
+	downloadedBytes: z.number(),
+	filesAdded: z.number(),
+	sessionCount: z.number(),
+	secondsActive: z.number()
+}).passthrough();
+const SessionStatsResponseSchema = z.object({
+	activeTorrentCount: z.number(),
+	downloadSpeed: z.number(),
+	pausedTorrentCount: z.number(),
+	torrentCount: z.number(),
+	uploadSpeed: z.number(),
+	"cumulative-stats": StatsSchema,
+	"current-stats": StatsSchema
+}).passthrough();
+const SessionCloseRequestSchema = z.never();
+const FreeSpaceResponseSchema = z.object({
+	path: z.string(),
+	"size-bytes": z.number()
+}).passthrough();
+const FreeSpaceRequestSchema = z.object({ path: z.string() });
+const FileSchema = z.object({
+	bytesCompleted: z.number(),
+	length: z.number(),
+	name: z.string(),
+	beginPiece: z.number().optional(),
+	endPiece: z.number().optional()
+}).passthrough();
+const FileStatsSchema = z.object({
+	bytesCompleted: z.number(),
+	wanted: z.boolean(),
+	priority: z.nativeEnum(Priority)
+}).passthrough();
+const PeerSchema = z.object({
+	address: z.string(),
+	clientName: z.string(),
+	clientIsChoked: z.boolean(),
+	clientIsInterested: z.boolean(),
+	flagStr: z.string(),
+	isDownloadingFrom: z.boolean(),
+	isEncrypted: z.boolean(),
+	isIncoming: z.boolean(),
+	isUploadingTo: z.boolean(),
+	isUTP: z.boolean(),
+	peerIsChoked: z.boolean(),
+	peerIsInterested: z.boolean(),
+	port: z.number(),
+	progress: z.number(),
+	rateToClient: z.number(),
+	rateToPeer: z.number()
+}).passthrough();
+const PeersFromSchema = z.object({
+	fromCache: z.number(),
+	fromDht: z.number(),
+	fromIncoming: z.number(),
+	fromLpd: z.number(),
+	fromLtep: z.number(),
+	fromPex: z.number(),
+	fromTracker: z.number()
+}).passthrough();
+const TrackerSchema = z.object({
+	announce: z.string(),
+	id: z.number(),
+	scrape: z.string(),
+	sitename: z.string().optional(),
+	tier: z.number()
+}).passthrough();
+const TrackerStatsSchema = z.object({
+	announce: z.string(),
+	announceState: z.number(),
+	downloadCount: z.number(),
+	hasAnnounced: z.boolean(),
+	hasScraped: z.boolean(),
+	host: z.string(),
+	id: z.number(),
+	isBackup: z.boolean(),
+	lastAnnouncePeerCount: z.number(),
+	lastAnnounceResult: z.string(),
+	lastAnnounceStartTime: z.number(),
+	lastAnnounceSucceeded: z.boolean(),
+	lastAnnounceTime: z.number(),
+	lastAnnounceTimedOut: z.boolean(),
+	lastScrapeResult: z.string(),
+	lastScrapeStartTime: z.number(),
+	lastScrapeSucceeded: z.boolean(),
+	lastScrapeTime: z.number(),
+	lastScrapeTimedOut: z.boolean(),
+	leecherCount: z.number(),
+	nextAnnounceTime: z.number(),
+	nextScrapeTime: z.number(),
+	scrape: z.string(),
+	scrapeState: z.number(),
+	seederCount: z.number(),
+	sitename: z.string().optional(),
+	tier: z.number()
+}).passthrough();
+const TorrentSchema = z.object({
+	activityDate: z.number().optional(),
+	addedDate: z.number().optional(),
+	availability: z.array(z.number()).optional(),
+	bandwidthPriority: z.nativeEnum(Priority).optional(),
+	comment: z.string().optional(),
+	corruptEver: z.number().optional(),
+	creator: z.string().optional(),
+	dateCreated: z.number().optional(),
+	desiredAvailable: z.number().optional(),
+	doneDate: z.number().optional(),
+	downloadDir: z.string().optional(),
+	downloadedEver: z.number().optional(),
+	downloadLimit: z.number().optional(),
+	downloadLimited: z.boolean().optional(),
+	editDate: z.number().optional(),
+	error: z.number().optional(),
+	errorString: z.string().optional(),
+	eta: z.number().optional(),
+	etaIdle: z.number().optional(),
+	"file-count": z.number().optional(),
+	files: z.array(FileSchema).optional(),
+	fileStats: z.array(FileStatsSchema).optional(),
+	group: z.string().optional(),
+	hashString: z.string().optional(),
+	haveUnchecked: z.number().optional(),
+	haveValid: z.number().optional(),
+	honorsSessionLimits: z.boolean().optional(),
+	id: z.number().optional(),
+	isFinished: z.boolean().optional(),
+	isPrivate: z.boolean().optional(),
+	isStalled: z.boolean().optional(),
+	labels: z.array(z.string()).optional(),
+	leftUntilDone: z.number().optional(),
+	magnetLink: z.string().optional(),
+	manualAnnounceTime: z.number().optional(),
+	maxConnectedPeers: z.number().optional(),
+	metadataPercentComplete: z.number().optional(),
+	name: z.string().optional(),
+	"peer-limit": z.number().optional(),
+	peers: z.array(PeerSchema).optional(),
+	peersConnected: z.number().optional(),
+	peersFrom: PeersFromSchema.optional(),
+	peersGettingFromUs: z.number().optional(),
+	peersSendingToUs: z.number().optional(),
+	percentComplete: z.number().optional(),
+	percentDone: z.number().optional(),
+	pieces: z.string().optional(),
+	pieceCount: z.number().optional(),
+	pieceSize: z.number().optional(),
+	priorities: z.array(z.nativeEnum(Priority)).optional(),
+	"primary-mime-type": z.string().optional(),
+	queuePosition: z.number().optional(),
+	rateDownload: z.number().optional(),
+	rateUpload: z.number().optional(),
+	recheckProgress: z.number().optional(),
+	secondsDownloading: z.number().optional(),
+	secondsSeeding: z.number().optional(),
+	seedIdleLimit: z.number().optional(),
+	seedIdleMode: z.nativeEnum(Mode).optional(),
+	seedRatioLimit: z.number().optional(),
+	seedRatioMode: z.nativeEnum(Mode).optional(),
+	sequentialDownload: z.boolean().optional(),
+	sizeWhenDone: z.number().optional(),
+	startDate: z.number().optional(),
+	status: z.nativeEnum(TorrentStatus).optional(),
+	trackers: z.array(TrackerSchema).optional(),
+	trackerList: z.string().optional(),
+	trackerStats: z.array(TrackerStatsSchema).optional(),
+	totalSize: z.number().optional(),
+	torrentFile: z.string().optional(),
+	uploadedEver: z.number().optional(),
+	uploadLimit: z.number().optional(),
+	uploadLimited: z.boolean().optional(),
+	uploadRatio: z.number().optional(),
+	wanted: z.array(z.number()).optional(),
+	webseeds: z.array(z.string()).optional(),
+	webseedsSendingToUs: z.number().optional()
+}).passthrough();
+const TorrentFormatSchema = z.enum(["objects", "table"]);
+const TorrentFieldSchema = z.enum([
+	"activityDate",
+	"addedDate",
+	"availability",
+	"bandwidthPriority",
+	"comment",
+	"corruptEver",
+	"creator",
+	"dateCreated",
+	"desiredAvailable",
+	"doneDate",
+	"downloadDir",
+	"downloadedEver",
+	"downloadLimit",
+	"downloadLimited",
+	"editDate",
+	"error",
+	"errorString",
+	"eta",
+	"etaIdle",
+	"file-count",
+	"files",
+	"fileStats",
+	"group",
+	"hashString",
+	"haveUnchecked",
+	"haveValid",
+	"honorsSessionLimits",
+	"id",
+	"isFinished",
+	"isPrivate",
+	"isStalled",
+	"labels",
+	"leftUntilDone",
+	"magnetLink",
+	"manualAnnounceTime",
+	"maxConnectedPeers",
+	"metadataPercentComplete",
+	"name",
+	"peer-limit",
+	"peers",
+	"peersConnected",
+	"peersFrom",
+	"peersGettingFromUs",
+	"peersSendingToUs",
+	"percentComplete",
+	"percentDone",
+	"pieces",
+	"pieceCount",
+	"pieceSize",
+	"priorities",
+	"primary-mime-type",
+	"queuePosition",
+	"rateDownload",
+	"rateUpload",
+	"recheckProgress",
+	"secondsDownloading",
+	"secondsSeeding",
+	"seedIdleLimit",
+	"seedIdleMode",
+	"seedRatioLimit",
+	"seedRatioMode",
+	"sequentialDownload",
+	"sizeWhenDone",
+	"startDate",
+	"status",
+	"trackers",
+	"trackerList",
+	"trackerStats",
+	"totalSize",
+	"torrentFile",
+	"uploadedEver",
+	"uploadLimit",
+	"uploadLimited",
+	"uploadRatio",
+	"wanted",
+	"webseeds",
+	"webseedsSendingToUs"
+]);
+const TorrentGetResponseSchema = z.object({
+	torrents: z.array(TorrentSchema),
+	removed: z.array(z.number()).optional()
+}).passthrough();
+const TorrentGetRequestSchema = IdentifiersSchema.extend({
+	fields: z.array(TorrentFieldSchema),
+	format: TorrentFormatSchema.optional()
+});
+const TorrentStartRequestSchema = IdentifiersSchema;
+const TorrentStartNowRequestSchema = IdentifiersSchema;
+const TorrentStopRequestSchema = IdentifiersSchema;
+const TorrentVerifyRequestSchema = IdentifiersSchema;
+const TorrentReannounceRequestSchema = IdentifiersSchema;
+const TorrentSetRequestSchema = IdentifiersSchema.extend({
+	bandwidthPriority: z.nativeEnum(Priority).optional(),
+	downloadLimit: z.number().optional(),
+	downloadLimited: z.boolean().optional(),
+	"files-wanted": z.array(z.number()).optional(),
+	"files-unwanted": z.array(z.number()).optional(),
+	honorsSessionLimits: z.boolean().optional(),
+	labels: z.array(z.string()).optional(),
+	location: z.string().optional(),
+	"peer-limit": z.number().optional(),
+	"priority-high": z.array(z.number()).optional(),
+	"priority-low": z.array(z.number()).optional(),
+	"priority-normal": z.array(z.number()).optional(),
+	queuePosition: z.number().optional(),
+	seedIdleLimit: z.number().optional(),
+	seedIdleMode: z.nativeEnum(Mode).optional(),
+	seedRatioLimit: z.number().optional(),
+	seedRatioMode: z.nativeEnum(Mode).optional(),
+	trackerAdd: z.array(z.string()).optional(),
+	trackerRemove: z.array(z.number()).optional(),
+	trackerReplace: z.array(z.object({
+		id: z.number(),
+		announce: z.string()
+	})).optional(),
+	trackerList: z.string().optional(),
+	group: z.string().optional(),
+	sequentialDownload: z.boolean().optional(),
+	uploadLimit: z.number().optional(),
+	uploadLimited: z.boolean().optional()
+});
+const TorrentAddOptionalsSchema = z.object({
+	cookies: z.string().optional(),
+	"download-dir": z.string().optional(),
+	labels: z.array(z.string()).optional(),
+	paused: z.boolean().optional(),
+	"peer-limit": z.number().optional(),
+	bandwidthPriority: z.number().optional(),
+	"files-wanted": z.array(z.number()).optional(),
+	"files-unwanted": z.array(z.number()).optional(),
+	"priority-high": z.array(z.number()).optional(),
+	"priority-low": z.array(z.number()).optional(),
+	"priority-normal": z.array(z.number()).optional(),
+	"sequential-download": z.boolean().optional()
+});
+const TorrentAddRequestSchema = z.union([TorrentAddOptionalsSchema.extend({ filename: z.string() }), TorrentAddOptionalsSchema.extend({ metainfo: z.string() })]);
+const TorrentAddResultSchema = z.object({
+	id: z.number().optional(),
+	name: z.string().optional(),
+	hashString: z.string().optional()
+}).passthrough();
+const TorrentAddResponseSchema = z.union([z.object({ "torrent-added": z.array(TorrentAddResultSchema) }).passthrough(), z.object({ "torrent-duplicate": z.array(TorrentAddResultSchema) }).passthrough()]);
+const TorrentRemoveRequestSchema = IdentifiersSchema.extend({ "delete-local-data": z.boolean().optional() });
+const TorrentSetLocationRequestSchema = IdentifiersSchema.extend({
+	location: z.string(),
+	move: z.boolean().optional()
+});
+const TorrentRenamePathRequestSchema = IdentifiersSchema.extend({
+	path: z.string(),
+	name: z.string()
+});
+const TorrentRenamePathResponseSchema = z.object({
+	path: z.string(),
+	name: z.string(),
+	id: z.number()
+}).passthrough();
+const QueueMoveTopRequestSchema = IdentifiersSchema;
+const QueueMoveUpRequestSchema = IdentifiersSchema;
+const QueueMoveDownRequestSchema = IdentifiersSchema;
+const QueueMoveBottomRequestSchema = IdentifiersSchema;
+const BlocklistUpdateRequestSchema = z.never();
+const BlocklistUpdateResponseSchema = z.object({ "blocklist-size": z.number() }).passthrough();
+const PortTestRequestSchema = z.object({ ipProtocol: z.enum(["ipv4", "ipv6"]).optional() });
+const PortTestResponseSchema = z.object({
+	"port-is-open": z.boolean(),
+	ipProtocol: z.enum(["ipv4", "ipv6"]).optional()
+}).passthrough();
+const BandwidthGroupSchema = z.object({
+	honorsSessionLimits: z.boolean(),
+	name: z.string(),
+	"speed-limit-down-enabled": z.boolean(),
+	"speed-limit-down": z.number(),
+	"speed-limit-up-enabled": z.boolean(),
+	"speed-limit-up": z.number()
+}).passthrough();
+const GroupGetRequestSchema = z.object({ group: z.union([z.string(), z.array(z.string())]).optional() });
+const GroupGetResponseSchema = z.object({ group: z.array(BandwidthGroupSchema) }).passthrough();
+const GroupSetRequestSchema = z.object({
+	honorsSessionLimits: z.boolean().optional(),
+	name: z.string(),
+	"speed-limit-down-enabled": z.boolean().optional(),
+	"speed-limit-down": z.number().optional(),
+	"speed-limit-up-enabled": z.boolean().optional(),
+	"speed-limit-up": z.number().optional()
+});
+
+//#endregion
+export { BandwidthGroupSchema, BlocklistUpdateRequestSchema, BlocklistUpdateResponseSchema, FreeSpaceRequestSchema, FreeSpaceResponseSchema, GroupGetRequestSchema, GroupGetResponseSchema, GroupSetRequestSchema, PortTestRequestSchema, PortTestResponseSchema, QueueMoveBottomRequestSchema, QueueMoveDownRequestSchema, QueueMoveTopRequestSchema, QueueMoveUpRequestSchema, SessionCloseRequestSchema, SessionGetRequestSchema, SessionGetResponseSchema, SessionSetRequestSchema, SessionStatsResponseSchema, TorrentAddRequestSchema, TorrentAddResponseSchema, TorrentFormatSchema, TorrentGetRequestSchema, TorrentGetResponseSchema, TorrentReannounceRequestSchema, TorrentRemoveRequestSchema, TorrentRenamePathRequestSchema, TorrentRenamePathResponseSchema, TorrentSchema, TorrentSetLocationRequestSchema, TorrentSetRequestSchema, TorrentStartNowRequestSchema, TorrentStartRequestSchema, TorrentStopRequestSchema, TorrentVerifyRequestSchema };

package/dist/torrent-get-BosdT1jx.d.cts

@@ -0,0 +1,195 @@
+//#region src/rpc-calls/utils.d.ts
+type Identifiers = {
+  ids?: number | (number | string)[] | "recently-active";
+};
+//#endregion
+//#region src/rpc-calls/torrent-get.d.ts
+type File = {
+  bytesCompleted: number;
+  length: number;
+  name: string;
+  beginPiece?: number;
+  endPiece?: number;
+};
+type FileStats = {
+  bytesCompleted: number;
+  wanted: boolean;
+  priority: Priority;
+};
+type Peer = {
+  address: string;
+  clientName: string;
+  clientIsChoked: boolean;
+  clientIsInterested: boolean;
+  flagStr: string;
+  isDownloadingFrom: boolean;
+  isEncrypted: boolean;
+  isIncoming: boolean;
+  isUploadingTo: boolean;
+  isUTP: boolean;
+  peerIsChoked: boolean;
+  peerIsInterested: boolean;
+  port: number;
+  progress: number;
+  rateToClient: number;
+  rateToPeer: number;
+};
+type PeersFrom = {
+  fromCache: number;
+  fromDht: number;
+  fromIncoming: number;
+  fromLpd: number;
+  fromLtep: number;
+  fromPex: number;
+  fromTracker: number;
+};
+type Tracker = {
+  announce: string;
+  id: number;
+  scrape: string;
+  sitename?: string;
+  tier: number;
+};
+type TrackerStats = {
+  announce: string;
+  announceState: number;
+  downloadCount: number;
+  hasAnnounced: boolean;
+  hasScraped: boolean;
+  host: string;
+  id: number;
+  isBackup: boolean;
+  lastAnnouncePeerCount: number;
+  lastAnnounceResult: string;
+  lastAnnounceStartTime: number;
+  lastAnnounceSucceeded: boolean;
+  lastAnnounceTime: number;
+  lastAnnounceTimedOut: boolean;
+  lastScrapeResult: string;
+  lastScrapeStartTime: number;
+  lastScrapeSucceeded: boolean;
+  lastScrapeTime: number;
+  lastScrapeTimedOut: boolean;
+  leecherCount: number;
+  nextAnnounceTime: number;
+  nextScrapeTime: number;
+  scrape: string;
+  scrapeState: number;
+  seederCount: number;
+  sitename?: string;
+  tier: number;
+};
+declare enum TorrentStatus {
+  STOPPED = 0,
+  QUEUED_TO_VERIFY_LOCAL_DATA = 1,
+  VERIFYING_LOCAL_DATA = 2,
+  QUEUED_TO_DOWNLOAD = 3,
+  DOWNLOADING = 4,
+  QUEUED_TO_SEED = 5,
+  SEEDING = 6
+}
+declare enum Priority {
+  LOW = -1,
+  NORMAL = 0,
+  HIGH = 1
+}
+declare enum Mode {
+  GLOBAL = 0,
+  SINGLE = 1,
+  UNLIMITED = 2
+}
+type Torrent = {
+  activityDate?: number;
+  addedDate?: number;
+  availability?: number[];
+  bandwidthPriority?: Priority;
+  comment?: string;
+  corruptEver?: number;
+  creator?: string;
+  dateCreated?: number;
+  desiredAvailable?: number;
+  doneDate?: number;
+  downloadDir?: string;
+  downloadedEver?: number;
+  downloadLimit?: number;
+  downloadLimited?: boolean;
+  editDate?: number;
+  error?: number;
+  errorString?: string;
+  eta?: number;
+  etaIdle?: number;
+  "file-count"?: number;
+  files?: File[];
+  fileStats?: FileStats[];
+  group?: string;
+  hashString?: string;
+  haveUnchecked?: number;
+  haveValid?: number;
+  honorsSessionLimits?: boolean;
+  id?: number;
+  isFinished?: boolean;
+  isPrivate?: boolean;
+  isStalled?: boolean;
+  labels?: string[];
+  leftUntilDone?: number;
+  magnetLink?: string;
+  manualAnnounceTime?: number;
+  maxConnectedPeers?: number;
+  metadataPercentComplete?: number;
+  name?: string;
+  "peer-limit"?: number;
+  peers?: Peer[];
+  peersConnected?: number;
+  peersFrom?: PeersFrom;
+  peersGettingFromUs?: number;
+  peersSendingToUs?: number;
+  percentComplete?: number;
+  percentDone?: number;
+  pieces?: string;
+  pieceCount?: number;
+  pieceSize?: number;
+  priorities?: Priority[];
+  "primary-mime-type"?: string;
+  queuePosition?: number;
+  rateDownload?: number;
+  rateUpload?: number;
+  recheckProgress?: number;
+  secondsDownloading?: number;
+  secondsSeeding?: number;
+  seedIdleLimit?: number;
+  seedIdleMode?: Mode;
+  seedRatioLimit?: number;
+  seedRatioMode?: Mode;
+  sequentialDownload?: boolean;
+  sizeWhenDone?: number;
+  startDate?: number;
+  status?: TorrentStatus;
+  trackers?: Tracker[];
+  trackerList?: string;
+  trackerStats?: TrackerStats[];
+  totalSize?: number;
+  torrentFile?: string;
+  uploadedEver?: number;
+  uploadLimit?: number;
+  uploadLimited?: boolean;
+  uploadRatio?: number;
+  wanted?: number[];
+  webseeds?: string[];
+  webseedsSendingToUs?: number;
+};
+type TorrentFormat = "objects" | "table";
+type TorrentField = keyof Torrent;
+type SelectedTorrentFields<F extends readonly TorrentField[]> = { [K in F[number]]-?: NonNullable<Torrent[K]> };
+type IsTuple<T extends readonly unknown[]> = number extends T["length"] ? false : true;
+type TorrentForFields<F extends readonly TorrentField[]> = IsTuple<F> extends true ? SelectedTorrentFields<F> : Torrent;
+type ResponseFor<F extends readonly TorrentField[]> = {
+  torrents: TorrentForFields<F>[];
+  removed?: number[];
+};
+type Response = ResponseFor<readonly TorrentField[]>;
+type Request<F extends readonly TorrentField[] = readonly TorrentField[]> = Identifiers & {
+  fields: F;
+  format?: TorrentFormat;
+};
+//#endregion
+export { ResponseFor as a, TorrentStatus as c, Response as i, Identifiers as l, Priority as n, TorrentField as o, Request as r, TorrentForFields as s, Mode as t };