stash-graphql-client 0.0.0-stage → 0.31.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shalemore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,226 @@
-# Temporary Holding Version
+# stash-graphql-client
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A fully typed client for the [Stash](https://github.com/stashapp/stash) GraphQL API, without writing GraphQL.
+
+- **Pick fields by reading them.** Your editor autocompletes them, and the result type has exactly the fields you picked.
+- **Generated from Stash's own schema** (latest release, see `STASH_VERSION`), so the names match.
+- **No dependencies.** It just uses `fetch`, and is about 4.5 KB gzipped.
+
+```sh
+bun add stash-graphql-client
+```
+
+## Quick start
+
+```ts
+import { createStash } from "stash-graphql-client";
+
+const stash = createStash({
+  endpoint: "http://localhost:9999/graphql",
+  apiKey: process.env.STASH_API_KEY, // sent as the ApiKey header
+});
+
+// Every root field is a method: (arguments, what to select)
+const { count, performers } = await stash.findPerformers(
+  { filter: { per_page: 20, sort: "name", direction: "ASC" } },
+  (result) => ({
+    count: result.count,
+    performers: result.performers((performer) => ({
+      id: performer.id,
+      name: performer.name,
+      favorite: performer.favorite,
+    })),
+  }),
+);
+// count: number
+// performers: { id: string; name: string; favorite: boolean }[]
+
+await stash.findPerformers((result) => ({ count: result.cont }));
+//                                                      ~~~~ unknown field
+```
+
+## Good to know
+
+- **Looking for a field or argument?** Everything is typed, with the schema's docs as JSDoc. In the installed package, see `dist/generated/schema.d.ts` for object and input types and `dist/generated/roots.d.ts` for the root fields.
+- **Read scalars, call objects.** `found.title` selects a scalar; `found.studio(...)` selects an object with a nested selection.
+- **Return only selections.** The returned object may contain just selected fields, nested selections and `$on` spreads. Compute things after the request, not inside the callback.
+- **Reach for plain GraphQL last.** Use `stash.request` only for something the typed API can't express.
+
+## Selecting fields
+
+```ts
+const scene = await stash.findScene({ id: "42" }, (found) => ({
+  id: found.id,
+  title: found.title, // string | null, same as in the schema
+  studio: found.studio((studio) => ({ id: studio.id, name: studio.name })), // call it to pick nested fields
+}));
+```
+
+Want a different name? Just use a different key. Fields with arguments can even be picked twice:
+
+```ts
+const { groups } = await stash.findGroups((result) => ({
+  groups: result.groups((group) => ({
+    id: group.id,
+    rating: group.rating100,
+    directScenes: group.scene_count({ depth: 0 }),
+    allScenes: group.scene_count({ depth: -1 }),
+  })),
+}));
+```
+
+For unions and interfaces, use `$on` to pick fields of one type. `__typename` is added for you, so you can narrow on it:
+
+```ts
+const image = await stash.findImage({ id: "7" }, (found) => ({
+  visual_files: found.visual_files((file) => ({
+    ...file.$on("ImageFile", (picture) => ({ path: picture.path, width: picture.width })),
+    ...file.$on("VideoFile", (video) => ({ path: video.path, duration: video.duration })),
+  })),
+}));
+
+for (const file of image?.visual_files ?? []) {
+  if (file.__typename === "ImageFile") console.log(file.width);
+}
+```
+
+Enums and input types are exported with the same names as in the schema:
+
+```ts
+import type { CriterionModifier, SceneFilterType } from "stash-graphql-client";
+
+const favorites: SceneFilterType = {
+  performer_favorite: true,
+  rating100: { value: 80, modifier: "GREATER_THAN" satisfies CriterionModifier },
+};
+
+await stash.findScenes({ scene_filter: favorites }, (result) => ({ count: result.count }));
+```
+
+## Reusing selections
+
+A selection is just a function, so you can share it like a fragment. `Fields` and `Result` are only types, so they cost nothing at runtime:
+
+```ts
+import type { Args, Fields, Result } from "stash-graphql-client";
+
+const tagFields = ({ id, name }: Fields<"Tag">) => ({ id, name });
+
+export const performerCard = (performer: Fields<"Performer">) => ({
+  id: performer.id,
+  name: performer.name,
+  image: performer.image_path,
+  tags: performer.tags(tagFields),
+});
+
+export type PerformerCard = Result<typeof performerCard>;
+// { id: string; name: string; image: string | null; tags: { id: string; name: string }[] }
+
+type ScenesArgs = Args<"findScenes">;
+
+// Add parameters to make it configurable
+const sceneCard = (scene: Fields<"Scene">, withFiles: boolean) => ({
+  id: scene.id,
+  tags: scene.tags(tagFields),
+  ...(withFiles ? { files: scene.files(({ path, size }) => ({ path, size })) } : {}), // files?: ...
+});
+```
+
+Callbacks run once, just to build the request, so don't `await` or do side effects in them. Destructuring the parameter picks those fields, but `...rest` picks nothing.
+
+## Several root fields in one request
+
+```ts
+const totals = await stash.query((query) => ({
+  scenes: query.findScenes((result) => ({ count: result.count })),
+  favorites: query.findScenes({ scene_filter: { performer_favorite: true } }, (result) => ({
+    count: result.count,
+  })),
+  performers: query.findPerformers((result) => ({ count: result.count })),
+}));
+
+totals.favorites.count; // number
+```
+
+That's a single HTTP request, and the keys become aliases. `mutation` works the same way and runs in the order you wrote. A query and a mutation can't share a request, and Stash doesn't accept batched HTTP, so use `Promise.all` to run them side by side.
+
+## Mutations and file uploads
+
+```ts
+const updated = await stash.performerUpdate(
+  { input: { id: "3", favorite: true, rating100: 90 } },
+  (performer) => ({ id: performer.id, favorite: performer.favorite }),
+);
+
+// Returns a plain boolean, so there's nothing to select
+const deleted: boolean = await stash.performerDestroy({ input: { id: "3" } });
+
+// Pass a Blob or File for uploads
+const jobId = await stash.importObjects({
+  input: {
+    file: Bun.file("export.zip"),
+    duplicateBehaviour: "IGNORE",
+    missingRefBehaviour: "IGNORE",
+  },
+});
+```
+
+## Subscriptions
+
+```ts
+// Returns an async iterator; leaving the loop unsubscribes
+const jobs = stash.jobsSubscribe((update) => ({
+  type: update.type,
+  job: update.job((job) => ({ id: job.id, progress: job.progress })),
+}));
+
+for await (const update of jobs) {
+  console.log(update.type, update.job.progress);
+  if (update.type === "REMOVE") break;
+}
+```
+
+## Raw GraphQL and errors
+
+```ts
+import { StashError } from "stash-graphql-client";
+
+try {
+  // Send any GraphQL you like; the result is untyped
+  await stash.request(`query ($id: ID!) { scene: findScene(id: $id) { id title } }`, { id: "42" });
+} catch (error) {
+  // If part of the request worked, that data is in error.data
+  if (error instanceof StashError) console.error(error.status, error.errors);
+}
+```
+
+## Options
+
+```ts
+createStash({
+  endpoint: "https://stash.example.com/graphql",
+  apiKey: "...",
+  headers: { "X-Proxy-Token": "..." }, // e.g. for a reverse proxy
+  fetch: (url, init) => fetch(url, { ...init, signal: AbortSignal.timeout(10_000) }), // or any fetch-like function
+  // subscriptions: your own graphql-ws client
+});
+```
+
+## Development
+
+There's a script you can run against your own server in [`example/index.ts`](example/index.ts): `STASH_URL=http://localhost:9999 STASH_API_KEY=... bun example/index.ts`.
+
+```sh
+bun install
+bun check          # type check
+bun run lint       # oxfmt and oxlint
+bun test           # also type-checks the examples in this README
+bun run build      # writes dist
+bun run schema     # update to the latest Stash release (or: bun run schema v0.30.0)
+```
+
+> [!NOTE]
+> `@defer` isn't supported. Stash declares it but ignores it and always sends the full result.
+
+> [!NOTE]
+> This project was written with AI, and it runs in my own projects day to day. If you hit a bug, please [open an issue](https://github.com/shalemore/stash-graphql-client/issues/new/choose).

package/dist/client.d.ts

@@ -0,0 +1,15 @@
+import { type StashOptions } from "./transport.ts";
+import type { Fields, Output, RootMethods, Selection } from "./types.ts";
+/** A client with one method per root field, plus `query`, `mutation` and `request`. */
+export interface StashClient extends RootMethods {
+    /**
+     * Sends several queries in one request. The keys become the result keys, so the same root
+     * field can be selected twice with different arguments.
+     */
+    query<S extends Selection>(select: (query: Fields<"Query">) => S): Promise<Output<"Query", S>>;
+    /** Sends several mutations in one request; Stash runs them in order. */
+    mutation<S extends Selection>(select: (mutation: Fields<"Mutation">) => S): Promise<Output<"Mutation", S>>;
+    /** Sends any GraphQL document as is and returns the untyped `data`. */
+    request(query: string, variables?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+export declare function createStash(options: StashOptions): StashClient;

package/dist/client.js

@@ -0,0 +1,29 @@
+import { ROOTS } from "./generated/roots.js";
+import { buildRequest, field, fields } from "./request.js";
+import { createTransport } from "./transport.js";
+export function createStash(options) {
+    const transport = createTransport(options);
+    // Async, so that errors in selection callbacks reject instead of throwing.
+    const send = async (kind, select) => {
+        const { request, upload } = buildRequest(kind, select());
+        return transport.send(request, upload);
+    };
+    const operation = (kind) => (select) => send(kind, () => select(fields));
+    const methods = Object.fromEntries(Object.entries(ROOTS).map(([name, [kind]]) => {
+        const root = (args, select) => ({ [name]: field(name)(args, select) });
+        return [
+            name,
+            kind === "subscription"
+                ? (args, select) => transport.subscribe(buildRequest(kind, root(args, select)).request, name)
+                : async (args, select) => (await send(kind, () => root(args, select)))[name],
+        ];
+    }));
+    const client = {
+        ...methods,
+        query: operation("query"),
+        mutation: operation("mutation"),
+        request: transport.request,
+    };
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- one method per entry in ROOTS
+    return client;
+}

package/dist/generated/roots.d.ts

@@ -0,0 +1,6 @@
+export declare const STASH_VERSION = "v0.31.1";
+export declare const ROOTS: Record<string, [
+    "query" | "mutation" | "subscription",
+    Record<string, string>,
+    true?
+]>;

package/dist/generated/roots.js

@@ -0,0 +1,281 @@
+// Generated by scripts/generate.ts from the schema of Stash v0.31.1. Do not edit.
+export const STASH_VERSION = "v0.31.1";
+export const ROOTS = {
+    findSavedFilter: ["query", { id: "ID!" }],
+    findSavedFilters: ["query", { mode: "FilterMode" }],
+    findDefaultFilter: ["query", { mode: "FilterMode!" }],
+    findFile: ["query", { id: "ID", path: "String" }],
+    findFiles: ["query", { file_filter: "FileFilterType", filter: "FindFilterType", ids: "[ID!]" }],
+    findFolder: ["query", { id: "ID", path: "String" }],
+    findFolders: [
+        "query",
+        { folder_filter: "FolderFilterType", filter: "FindFilterType", ids: "[ID!]" },
+    ],
+    findScene: ["query", { id: "ID", checksum: "String" }],
+    findSceneByHash: ["query", { input: "SceneHashInput!" }],
+    findScenes: [
+        "query",
+        {
+            scene_filter: "SceneFilterType",
+            scene_ids: "[Int!]",
+            ids: "[ID!]",
+            filter: "FindFilterType",
+        },
+    ],
+    findScenesByPathRegex: ["query", { filter: "FindFilterType" }],
+    findDuplicateScenes: ["query", { distance: "Int", duration_diff: "Float" }],
+    sceneStreams: ["query", { id: "ID" }],
+    parseSceneFilenames: ["query", { filter: "FindFilterType", config: "SceneParserInput!" }],
+    findSceneMarkers: [
+        "query",
+        { scene_marker_filter: "SceneMarkerFilterType", filter: "FindFilterType", ids: "[ID!]" },
+    ],
+    findImage: ["query", { id: "ID", checksum: "String" }],
+    findImages: [
+        "query",
+        {
+            image_filter: "ImageFilterType",
+            image_ids: "[Int!]",
+            ids: "[ID!]",
+            filter: "FindFilterType",
+        },
+    ],
+    findPerformer: ["query", { id: "ID!" }],
+    findPerformers: [
+        "query",
+        {
+            performer_filter: "PerformerFilterType",
+            filter: "FindFilterType",
+            performer_ids: "[Int!]",
+            ids: "[ID!]",
+        },
+    ],
+    findStudio: ["query", { id: "ID!" }],
+    findStudios: [
+        "query",
+        { studio_filter: "StudioFilterType", filter: "FindFilterType", ids: "[ID!]" },
+    ],
+    findMovie: ["query", { id: "ID!" }],
+    findMovies: [
+        "query",
+        { movie_filter: "MovieFilterType", filter: "FindFilterType", ids: "[ID!]" },
+    ],
+    findGroup: ["query", { id: "ID!" }],
+    findGroups: [
+        "query",
+        { group_filter: "GroupFilterType", filter: "FindFilterType", ids: "[ID!]" },
+    ],
+    findGallery: ["query", { id: "ID!" }],
+    findGalleries: [
+        "query",
+        { gallery_filter: "GalleryFilterType", filter: "FindFilterType", ids: "[ID!]" },
+    ],
+    findTag: ["query", { id: "ID!" }],
+    findTags: ["query", { tag_filter: "TagFilterType", filter: "FindFilterType", ids: "[ID!]" }],
+    markerWall: ["query", { q: "String" }],
+    sceneWall: ["query", { q: "String" }],
+    markerStrings: ["query", { q: "String", sort: "String" }],
+    stats: ["query", {}],
+    sceneMarkerTags: ["query", { scene_id: "ID!" }],
+    logs: ["query", {}],
+    listScrapers: ["query", { types: "[ScrapeContentType!]!" }],
+    scrapeSingleScene: ["query", { source: "ScraperSourceInput!", input: "ScrapeSingleSceneInput!" }],
+    scrapeMultiScenes: ["query", { source: "ScraperSourceInput!", input: "ScrapeMultiScenesInput!" }],
+    scrapeSingleStudio: [
+        "query",
+        { source: "ScraperSourceInput!", input: "ScrapeSingleStudioInput!" },
+    ],
+    scrapeSingleTag: ["query", { source: "ScraperSourceInput!", input: "ScrapeSingleTagInput!" }],
+    scrapeSinglePerformer: [
+        "query",
+        { source: "ScraperSourceInput!", input: "ScrapeSinglePerformerInput!" },
+    ],
+    scrapeMultiPerformers: [
+        "query",
+        { source: "ScraperSourceInput!", input: "ScrapeMultiPerformersInput!" },
+    ],
+    scrapeSingleGallery: [
+        "query",
+        { source: "ScraperSourceInput!", input: "ScrapeSingleGalleryInput!" },
+    ],
+    scrapeSingleMovie: ["query", { source: "ScraperSourceInput!", input: "ScrapeSingleMovieInput!" }],
+    scrapeSingleGroup: ["query", { source: "ScraperSourceInput!", input: "ScrapeSingleGroupInput!" }],
+    scrapeSingleImage: ["query", { source: "ScraperSourceInput!", input: "ScrapeSingleImageInput!" }],
+    scrapeURL: ["query", { url: "String!", ty: "ScrapeContentType!" }],
+    scrapePerformerURL: ["query", { url: "String!" }],
+    scrapeSceneURL: ["query", { url: "String!" }],
+    scrapeGalleryURL: ["query", { url: "String!" }],
+    scrapeImageURL: ["query", { url: "String!" }],
+    scrapeMovieURL: ["query", { url: "String!" }],
+    scrapeGroupURL: ["query", { url: "String!" }],
+    plugins: ["query", {}],
+    pluginTasks: ["query", {}],
+    installedPackages: ["query", { type: "PackageType!" }],
+    availablePackages: ["query", { type: "PackageType!", source: "String!" }],
+    configuration: ["query", {}],
+    directory: ["query", { path: "String", locale: "String" }],
+    validateStashBoxCredentials: ["query", { input: "StashBoxInput!" }],
+    systemStatus: ["query", {}],
+    jobQueue: ["query", {}],
+    findJob: ["query", { input: "FindJobInput!" }],
+    dlnaStatus: ["query", {}],
+    allScenes: ["query", {}],
+    allSceneMarkers: ["query", {}],
+    allImages: ["query", {}],
+    allGalleries: ["query", {}],
+    allPerformers: ["query", {}],
+    allTags: ["query", {}],
+    allStudios: ["query", {}],
+    allMovies: ["query", {}],
+    version: ["query", {}],
+    latestversion: ["query", {}],
+    setup: ["mutation", { input: "SetupInput!" }],
+    migrate: ["mutation", { input: "MigrateInput!" }],
+    downloadFFMpeg: ["mutation", {}],
+    sceneCreate: ["mutation", { input: "SceneCreateInput!" }],
+    sceneUpdate: ["mutation", { input: "SceneUpdateInput!" }],
+    sceneMerge: ["mutation", { input: "SceneMergeInput!" }],
+    bulkSceneUpdate: ["mutation", { input: "BulkSceneUpdateInput!" }],
+    sceneDestroy: ["mutation", { input: "SceneDestroyInput!" }],
+    scenesDestroy: ["mutation", { input: "ScenesDestroyInput!" }],
+    scenesUpdate: ["mutation", { input: "[SceneUpdateInput!]!" }],
+    sceneIncrementO: ["mutation", { id: "ID!" }],
+    sceneDecrementO: ["mutation", { id: "ID!" }],
+    sceneAddO: ["mutation", { id: "ID!", times: "[Timestamp!]" }],
+    sceneDeleteO: ["mutation", { id: "ID!", times: "[Timestamp!]" }],
+    sceneResetO: ["mutation", { id: "ID!" }],
+    sceneSaveActivity: ["mutation", { id: "ID!", resume_time: "Float", playDuration: "Float" }],
+    sceneResetActivity: [
+        "mutation",
+        { id: "ID!", reset_resume: "Boolean", reset_duration: "Boolean" },
+    ],
+    sceneIncrementPlayCount: ["mutation", { id: "ID!" }],
+    sceneAddPlay: ["mutation", { id: "ID!", times: "[Timestamp!]" }],
+    sceneDeletePlay: ["mutation", { id: "ID!", times: "[Timestamp!]" }],
+    sceneResetPlayCount: ["mutation", { id: "ID!" }],
+    sceneGenerateScreenshot: ["mutation", { id: "ID!", at: "Float" }],
+    sceneMarkerCreate: ["mutation", { input: "SceneMarkerCreateInput!" }],
+    sceneMarkerUpdate: ["mutation", { input: "SceneMarkerUpdateInput!" }],
+    bulkSceneMarkerUpdate: ["mutation", { input: "BulkSceneMarkerUpdateInput!" }],
+    sceneMarkerDestroy: ["mutation", { id: "ID!" }],
+    sceneMarkersDestroy: ["mutation", { ids: "[ID!]!" }],
+    sceneAssignFile: ["mutation", { input: "AssignSceneFileInput!" }],
+    imageUpdate: ["mutation", { input: "ImageUpdateInput!" }],
+    bulkImageUpdate: ["mutation", { input: "BulkImageUpdateInput!" }],
+    imageDestroy: ["mutation", { input: "ImageDestroyInput!" }],
+    imagesDestroy: ["mutation", { input: "ImagesDestroyInput!" }],
+    imagesUpdate: ["mutation", { input: "[ImageUpdateInput!]!" }],
+    imageIncrementO: ["mutation", { id: "ID!" }],
+    imageDecrementO: ["mutation", { id: "ID!" }],
+    imageResetO: ["mutation", { id: "ID!" }],
+    galleryCreate: ["mutation", { input: "GalleryCreateInput!" }],
+    galleryUpdate: ["mutation", { input: "GalleryUpdateInput!" }],
+    bulkGalleryUpdate: ["mutation", { input: "BulkGalleryUpdateInput!" }],
+    galleryDestroy: ["mutation", { input: "GalleryDestroyInput!" }],
+    galleriesUpdate: ["mutation", { input: "[GalleryUpdateInput!]!" }],
+    addGalleryImages: ["mutation", { input: "GalleryAddInput!" }],
+    removeGalleryImages: ["mutation", { input: "GalleryRemoveInput!" }],
+    setGalleryCover: ["mutation", { input: "GallerySetCoverInput!" }],
+    resetGalleryCover: ["mutation", { input: "GalleryResetCoverInput!" }],
+    galleryChapterCreate: ["mutation", { input: "GalleryChapterCreateInput!" }],
+    galleryChapterUpdate: ["mutation", { input: "GalleryChapterUpdateInput!" }],
+    galleryChapterDestroy: ["mutation", { id: "ID!" }],
+    performerCreate: ["mutation", { input: "PerformerCreateInput!" }],
+    performerUpdate: ["mutation", { input: "PerformerUpdateInput!" }],
+    performerDestroy: ["mutation", { input: "PerformerDestroyInput!" }],
+    performersDestroy: ["mutation", { ids: "[ID!]!" }],
+    bulkPerformerUpdate: ["mutation", { input: "BulkPerformerUpdateInput!" }],
+    performerMerge: ["mutation", { input: "PerformerMergeInput!" }],
+    studioCreate: ["mutation", { input: "StudioCreateInput!" }],
+    studioUpdate: ["mutation", { input: "StudioUpdateInput!" }],
+    studioDestroy: ["mutation", { input: "StudioDestroyInput!" }],
+    studiosDestroy: ["mutation", { ids: "[ID!]!" }],
+    bulkStudioUpdate: ["mutation", { input: "BulkStudioUpdateInput!" }],
+    movieCreate: ["mutation", { input: "MovieCreateInput!" }],
+    movieUpdate: ["mutation", { input: "MovieUpdateInput!" }],
+    movieDestroy: ["mutation", { input: "MovieDestroyInput!" }],
+    moviesDestroy: ["mutation", { ids: "[ID!]!" }],
+    bulkMovieUpdate: ["mutation", { input: "BulkMovieUpdateInput!" }],
+    groupCreate: ["mutation", { input: "GroupCreateInput!" }],
+    groupUpdate: ["mutation", { input: "GroupUpdateInput!" }],
+    groupDestroy: ["mutation", { input: "GroupDestroyInput!" }],
+    groupsDestroy: ["mutation", { ids: "[ID!]!" }],
+    bulkGroupUpdate: ["mutation", { input: "BulkGroupUpdateInput!" }],
+    addGroupSubGroups: ["mutation", { input: "GroupSubGroupAddInput!" }],
+    removeGroupSubGroups: ["mutation", { input: "GroupSubGroupRemoveInput!" }],
+    reorderSubGroups: ["mutation", { input: "ReorderSubGroupsInput!" }],
+    tagCreate: ["mutation", { input: "TagCreateInput!" }],
+    tagUpdate: ["mutation", { input: "TagUpdateInput!" }],
+    tagDestroy: ["mutation", { input: "TagDestroyInput!" }],
+    tagsDestroy: ["mutation", { ids: "[ID!]!" }],
+    tagsMerge: ["mutation", { input: "TagsMergeInput!" }],
+    bulkTagUpdate: ["mutation", { input: "BulkTagUpdateInput!" }],
+    moveFiles: ["mutation", { input: "MoveFilesInput!" }],
+    deleteFiles: ["mutation", { ids: "[ID!]!" }],
+    destroyFiles: ["mutation", { ids: "[ID!]!" }],
+    fileSetFingerprints: ["mutation", { input: "FileSetFingerprintsInput!" }],
+    revealFileInFileManager: ["mutation", { id: "ID!" }],
+    revealFolderInFileManager: ["mutation", { id: "ID!" }],
+    saveFilter: ["mutation", { input: "SaveFilterInput!" }],
+    destroySavedFilter: ["mutation", { input: "DestroyFilterInput!" }],
+    setDefaultFilter: ["mutation", { input: "SetDefaultFilterInput!" }],
+    configureGeneral: ["mutation", { input: "ConfigGeneralInput!" }],
+    configureInterface: ["mutation", { input: "ConfigInterfaceInput!" }],
+    configureDLNA: ["mutation", { input: "ConfigDLNAInput!" }],
+    configureScraping: ["mutation", { input: "ConfigScrapingInput!" }],
+    configureDefaults: ["mutation", { input: "ConfigDefaultSettingsInput!" }],
+    configurePlugin: ["mutation", { plugin_id: "ID!", input: "Map!" }],
+    configureUI: ["mutation", { input: "Map", partial: "Map" }],
+    configureUISetting: ["mutation", { key: "String!", value: "Any" }],
+    generateAPIKey: ["mutation", { input: "GenerateAPIKeyInput!" }],
+    exportObjects: ["mutation", { input: "ExportObjectsInput!" }],
+    importObjects: ["mutation", { input: "ImportObjectsInput!" }, true],
+    metadataImport: ["mutation", {}],
+    metadataExport: ["mutation", {}],
+    metadataScan: ["mutation", { input: "ScanMetadataInput!" }],
+    metadataGenerate: ["mutation", { input: "GenerateMetadataInput!" }],
+    metadataAutoTag: ["mutation", { input: "AutoTagMetadataInput!" }],
+    metadataClean: ["mutation", { input: "CleanMetadataInput!" }],
+    metadataCleanGenerated: ["mutation", { input: "CleanGeneratedInput!" }],
+    metadataIdentify: ["mutation", { input: "IdentifyMetadataInput!" }],
+    migrateHashNaming: ["mutation", {}],
+    migrateSceneScreenshots: ["mutation", { input: "MigrateSceneScreenshotsInput!" }],
+    migrateBlobs: ["mutation", { input: "MigrateBlobsInput!" }],
+    anonymiseDatabase: ["mutation", { input: "AnonymiseDatabaseInput!" }],
+    optimiseDatabase: ["mutation", {}],
+    reloadScrapers: ["mutation", {}],
+    setPluginsEnabled: ["mutation", { enabledMap: "BoolMap!" }],
+    runPluginTask: [
+        "mutation",
+        {
+            plugin_id: "ID!",
+            task_name: "String",
+            description: "String",
+            args: "[PluginArgInput!]",
+            args_map: "Map",
+        },
+    ],
+    runPluginOperation: ["mutation", { plugin_id: "ID!", args: "Map" }],
+    reloadPlugins: ["mutation", {}],
+    installPackages: ["mutation", { type: "PackageType!", packages: "[PackageSpecInput!]!" }],
+    updatePackages: ["mutation", { type: "PackageType!", packages: "[PackageSpecInput!]" }],
+    uninstallPackages: ["mutation", { type: "PackageType!", packages: "[PackageSpecInput!]!" }],
+    stopJob: ["mutation", { job_id: "ID!" }],
+    stopAllJobs: ["mutation", {}],
+    submitStashBoxFingerprints: ["mutation", { input: "StashBoxFingerprintSubmissionInput!" }],
+    submitStashBoxSceneDraft: ["mutation", { input: "StashBoxDraftSubmissionInput!" }],
+    submitStashBoxPerformerDraft: ["mutation", { input: "StashBoxDraftSubmissionInput!" }],
+    backupDatabase: ["mutation", { input: "BackupDatabaseInput!" }],
+    querySQL: ["mutation", { sql: "String!", args: "[Any]" }],
+    execSQL: ["mutation", { sql: "String!", args: "[Any]" }],
+    stashBoxBatchPerformerTag: ["mutation", { input: "StashBoxBatchTagInput!" }],
+    stashBoxBatchStudioTag: ["mutation", { input: "StashBoxBatchTagInput!" }],
+    stashBoxBatchTagTag: ["mutation", { input: "StashBoxBatchTagInput!" }],
+    enableDLNA: ["mutation", { input: "EnableDLNAInput!" }],
+    disableDLNA: ["mutation", { input: "DisableDLNAInput!" }],
+    addTempDLNAIP: ["mutation", { input: "AddTempDLNAIPInput!" }],
+    removeTempDLNAIP: ["mutation", { input: "RemoveTempDLNAIPInput!" }],
+    jobsSubscribe: ["subscription", {}],
+    loggingSubscribe: ["subscription", {}],
+    scanCompleteSubscribe: ["subscription", {}],
+};