stash-graphql-client 0.0.0-stage → 0.31.2

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,248 @@
-# 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.
+[![npm](https://img.shields.io/npm/v/stash-graphql-client)](https://www.npmjs.com/package/stash-graphql-client)
+[![CI](https://github.com/shalemore/stash-graphql-client/actions/workflows/ci.yml/badge.svg)](https://github.com/shalemore/stash-graphql-client/actions/workflows/ci.yml)
+[![License](https://img.shields.io/npm/l/stash-graphql-client)](LICENSE)
+
+A fully typed client for the [Stash](https://github.com/stashapp/stash) GraphQL API, without writing GraphQL.
+
+> This version of the package is generated from the GraphQL schema of [Stash v0.31.1](https://github.com/stashapp/stash/releases/tag/v0.31.1).
+
+- **Typed field selection.** Fields are selected with callbacks, and the result type contains exactly the selected fields.
+- **Generated from Stash's own schema** (the latest release, see [Stash versions](#stash-versions)), so the names match.
+- **Small.** Built on `fetch`, about 6 KB gzipped. The only dependency, `graphql-ws`, is loaded on the first subscription.
+
+```sh
+npm install 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,
+});
+
+// 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) => ({
+    ...result.$pick("count"),
+    performers: result.performers((performer) => performer.$pick("id", "name", "favorite")),
+  }),
+);
+// count: number
+// performers: { id: string; name: string; favorite: boolean }[]
+
+await stash.findPerformers((result) => result.$pick("cont"));
+//                                                  ~~~~~~ unknown field
+```
+
+## Selecting fields
+
+`$pick` selects scalar fields by name; an object field is called with its own selection:
+
+```ts
+const scene = await stash.findScene({ id: "42" }, (found) => ({
+  ...found.$pick("id", "title"), // title: string | null, same as in the schema
+  studio: found.studio((studio) => studio.$pick("id", "name")),
+}));
+```
+
+A scalar can also be read directly, which selects it under the same name:
+
+```ts
+const scene = await stash.findScene({ id: "42" }, (found) => ({
+  id: found.id,
+  title: found.title,
+  studio: found.studio((studio) => ({ id: studio.id, name: studio.name })),
+}));
+```
+
+Use a different key to rename a field. A field with arguments can be selected more than once under different keys:
+
+```ts
+const { groups } = await stash.findGroups((result) => ({
+  groups: result.groups((group) => ({
+    ...group.$pick("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 automatically, so the result can be narrowed on it:
+
+```ts
+const image = await stash.findImage({ id: "7" }, (found) => ({
+  visual_files: found.visual_files((file) => ({
+    ...file.$on("ImageFile", (picture) => picture.$pick("path", "width")),
+    ...file.$on("VideoFile", (video) => video.$pick("path", "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) => result.$pick("count"));
+```
+
+## Reusing selections
+
+A selection is a plain function, so it can be shared like a GraphQL fragment. `Fields` and `Result` are types only and have no runtime cost:
+
+```ts
+import type { Args, Fields, Result } from "stash-graphql-client";
+
+const tagFields = (tag: Fields<"Tag">) => tag.$pick("id", "name");
+
+export const performerCard = (performer: Fields<"Performer">) => ({
+  ...performer.$pick("id", "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 }[] }
+
+// Add parameters to make it configurable
+const sceneCard = (scene: Fields<"Scene">, withFiles: boolean) => ({
+  ...scene.$pick("id"),
+  tags: scene.tags(tagFields),
+  ...(withFiles ? { files: scene.files((file) => file.$pick("path", "size")) } : {}), // files?: ...
+});
+
+// Args is the argument type of a root field, handy for wrapping a call in your own function
+const listScenes = (args: Args<"findScenes">) =>
+  stash.findScenes(args, (result) => ({
+    ...result.$pick("count"),
+    scenes: result.scenes((scene) => sceneCard(scene, false)),
+  }));
+```
+
+Callbacks run once, only to build the request. They must return only fields, nested selections and `$on` spreads. Don't `await` or compute anything inside them; do that with the result instead.
+
+> [!WARNING]
+> Don't use `...rest` on the callback parameter. It is always empty, so nothing is selected.
+
+## Several root fields in one request
+
+```ts
+const totals = await stash.query((query) => ({
+  scenes: query.findScenes((result) => result.$pick("count")),
+  favorites: query.findScenes({ scene_filter: { performer_favorite: true } }, (result) =>
+    result.$pick("count"),
+  ),
+  performers: query.findPerformers((result) => result.$pick("count")),
+}));
+
+totals.favorites.count; // number
+```
+
+This sends a single HTTP request, and the keys become aliases. `mutation` works the same way and runs the fields in the order written. A query and a mutation can't share a request, and Stash doesn't accept batched HTTP, so use `Promise.all` to run them concurrently.
+
+## Mutations and file uploads
+
+```ts
+import { openAsBlob } from "node:fs";
+
+const updated = await stash.performerUpdate(
+  { input: { id: "3", favorite: true, rating100: 90 } },
+  (performer) => performer.$pick("id", "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: openAsBlob on Node, Bun.file on Bun, or a file input in the browser
+const jobId = await stash.importObjects({
+  input: {
+    file: await openAsBlob("export.zip"),
+    duplicateBehaviour: "IGNORE",
+    missingRefBehaviour: "IGNORE",
+  },
+});
+```
+
+## Subscriptions
+
+```ts
+// Returns an async iterator; leaving the loop unsubscribes
+const jobs = stash.jobsSubscribe((update) => ({
+  ...update.$pick("type"),
+  job: update.job((job) => job.$pick("id", "progress")),
+}));
+
+for await (const update of jobs) {
+  console.log(update.type, update.job.progress);
+  if (update.type === "REMOVE") break;
+}
+```
+
+Subscriptions go over a WebSocket through [`graphql-ws`](https://github.com/enisdenjo/graphql-ws). The client is created on the first subscription, at the same address as `endpoint` (`http` becomes `ws`, `https` becomes `wss`).
+
+- **Authentication.** On Node.js and Bun, `apiKey` and `headers` are sent with the WebSocket handshake too. Browsers can't set headers on a WebSocket, so there Stash has to recognize the session cookie.
+- **Needs a `WebSocket`.** That is global in browsers, on Node.js 22+ and on Bun. On older versions, or to configure reconnecting, pass your own `graphql-ws` client. A custom client must also handle authentication.
+
+```ts
+import { createClient } from "graphql-ws";
+
+const stash = createStash({
+  endpoint: "http://localhost:9999/graphql",
+  subscriptions: createClient({
+    url: "ws://localhost:9999/graphql",
+    webSocketImpl: WebSocket, // e.g. the `ws` package on older Node.js
+    retryAttempts: Infinity,
+  }),
+});
+```
+
+## Raw GraphQL and errors
+
+```ts
+import { StashError } from "stash-graphql-client";
+
+try {
+  // For what the typed API can't express; 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, see Subscriptions
+});
+```
+
+## Stash versions
+
+Package `0.31.x` tracks the Stash `v0.31` series; patch numbers are independent. `STASH_VERSION` is the Stash release the schema comes from.
+
+## License
+
+[MIT](LICENSE)

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", {}],
+};