refactor: unify backend and frontend servers (#3)

* refactor: unify backend and frontend servers * refactor: correct paths for openapi & drizzle * refactor: move api-client to client * fix: drizzle paths * chore: fix linting issues * fix: form reset issue
2025-12-10 12:10:51 +01:00 · 2025-11-13 20:11:46 +01:00
parent 8d7e50508d
commit 95a0d44b45
240 changed files with 5171 additions and 5875 deletions
--- a/app/client/api-client/@tanstack/react-query.gen.ts
+++ b/app/client/api-client/@tanstack/react-query.gen.ts
@@ -0,0 +1,955 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { type DefaultError, queryOptions, type UseMutationOptions } from "@tanstack/react-query";
+
+import { client } from "../client.gen";
+import {
+	browseFilesystem,
+	changePassword,
+	createBackupSchedule,
+	createRepository,
+	createVolume,
+	deleteBackupSchedule,
+	deleteRepository,
+	deleteVolume,
+	doctorRepository,
+	downloadResticPassword,
+	getBackupSchedule,
+	getBackupScheduleForVolume,
+	getContainersUsingVolume,
+	getMe,
+	getRepository,
+	getSnapshotDetails,
+	getStatus,
+	getSystemInfo,
+	getVolume,
+	healthCheckVolume,
+	listBackupSchedules,
+	listFiles,
+	listRcloneRemotes,
+	listRepositories,
+	listSnapshotFiles,
+	listSnapshots,
+	listVolumes,
+	login,
+	logout,
+	mountVolume,
+	type Options,
+	register,
+	restoreSnapshot,
+	runBackupNow,
+	stopBackup,
+	testConnection,
+	unmountVolume,
+	updateBackupSchedule,
+	updateVolume,
+} from "../sdk.gen";
+import type {
+	BrowseFilesystemData,
+	BrowseFilesystemResponse,
+	ChangePasswordData,
+	ChangePasswordResponse,
+	CreateBackupScheduleData,
+	CreateBackupScheduleResponse,
+	CreateRepositoryData,
+	CreateRepositoryResponse,
+	CreateVolumeData,
+	CreateVolumeResponse,
+	DeleteBackupScheduleData,
+	DeleteBackupScheduleResponse,
+	DeleteRepositoryData,
+	DeleteRepositoryResponse,
+	DeleteVolumeData,
+	DeleteVolumeResponse,
+	DoctorRepositoryData,
+	DoctorRepositoryResponse,
+	DownloadResticPasswordData,
+	DownloadResticPasswordResponse,
+	GetBackupScheduleData,
+	GetBackupScheduleForVolumeData,
+	GetBackupScheduleForVolumeResponse,
+	GetBackupScheduleResponse,
+	GetContainersUsingVolumeData,
+	GetContainersUsingVolumeResponse,
+	GetMeData,
+	GetMeResponse,
+	GetRepositoryData,
+	GetRepositoryResponse,
+	GetSnapshotDetailsData,
+	GetSnapshotDetailsResponse,
+	GetStatusData,
+	GetStatusResponse,
+	GetSystemInfoData,
+	GetSystemInfoResponse,
+	GetVolumeData,
+	GetVolumeResponse,
+	HealthCheckVolumeData,
+	HealthCheckVolumeResponse,
+	ListBackupSchedulesData,
+	ListBackupSchedulesResponse,
+	ListFilesData,
+	ListFilesResponse,
+	ListRcloneRemotesData,
+	ListRcloneRemotesResponse,
+	ListRepositoriesData,
+	ListRepositoriesResponse,
+	ListSnapshotFilesData,
+	ListSnapshotFilesResponse,
+	ListSnapshotsData,
+	ListSnapshotsResponse,
+	ListVolumesData,
+	ListVolumesResponse,
+	LoginData,
+	LoginResponse,
+	LogoutData,
+	LogoutResponse,
+	MountVolumeData,
+	MountVolumeResponse,
+	RegisterData,
+	RegisterResponse,
+	RestoreSnapshotData,
+	RestoreSnapshotResponse,
+	RunBackupNowData,
+	RunBackupNowResponse,
+	StopBackupData,
+	StopBackupResponse,
+	TestConnectionData,
+	TestConnectionResponse,
+	UnmountVolumeData,
+	UnmountVolumeResponse,
+	UpdateBackupScheduleData,
+	UpdateBackupScheduleResponse,
+	UpdateVolumeData,
+	UpdateVolumeResponse,
+} from "../types.gen";
+
+/**
+ * Register a new user
+ */
+export const registerMutation = (
+	options?: Partial<Options<RegisterData>>,
+): UseMutationOptions<RegisterResponse, DefaultError, Options<RegisterData>> => {
+	const mutationOptions: UseMutationOptions<RegisterResponse, DefaultError, Options<RegisterData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await register({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+/**
+ * Login with username and password
+ */
+export const loginMutation = (
+	options?: Partial<Options<LoginData>>,
+): UseMutationOptions<LoginResponse, DefaultError, Options<LoginData>> => {
+	const mutationOptions: UseMutationOptions<LoginResponse, DefaultError, Options<LoginData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await login({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+/**
+ * Logout current user
+ */
+export const logoutMutation = (
+	options?: Partial<Options<LogoutData>>,
+): UseMutationOptions<LogoutResponse, DefaultError, Options<LogoutData>> => {
+	const mutationOptions: UseMutationOptions<LogoutResponse, DefaultError, Options<LogoutData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await logout({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export type QueryKey<TOptions extends Options> = [
+	Pick<TOptions, "baseUrl" | "body" | "headers" | "path" | "query"> & {
+		_id: string;
+		_infinite?: boolean;
+		tags?: ReadonlyArray<string>;
+	},
+];
+
+const createQueryKey = <TOptions extends Options>(
+	id: string,
+	options?: TOptions,
+	infinite?: boolean,
+	tags?: ReadonlyArray<string>,
+): [QueryKey<TOptions>[0]] => {
+	const params: QueryKey<TOptions>[0] = {
+		_id: id,
+		baseUrl: options?.baseUrl || (options?.client ?? client).getConfig().baseUrl,
+	} as QueryKey<TOptions>[0];
+	if (infinite) {
+		params._infinite = infinite;
+	}
+	if (tags) {
+		params.tags = tags;
+	}
+	if (options?.body) {
+		params.body = options.body;
+	}
+	if (options?.headers) {
+		params.headers = options.headers;
+	}
+	if (options?.path) {
+		params.path = options.path;
+	}
+	if (options?.query) {
+		params.query = options.query;
+	}
+	return [params];
+};
+
+export const getMeQueryKey = (options?: Options<GetMeData>) => createQueryKey("getMe", options);
+
+/**
+ * Get current authenticated user
+ */
+export const getMeOptions = (options?: Options<GetMeData>) =>
+	queryOptions<GetMeResponse, DefaultError, GetMeResponse, ReturnType<typeof getMeQueryKey>>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await getMe({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: getMeQueryKey(options),
+	});
+
+export const getStatusQueryKey = (options?: Options<GetStatusData>) => createQueryKey("getStatus", options);
+
+/**
+ * Get authentication system status
+ */
+export const getStatusOptions = (options?: Options<GetStatusData>) =>
+	queryOptions<GetStatusResponse, DefaultError, GetStatusResponse, ReturnType<typeof getStatusQueryKey>>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await getStatus({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: getStatusQueryKey(options),
+	});
+
+/**
+ * Change current user password
+ */
+export const changePasswordMutation = (
+	options?: Partial<Options<ChangePasswordData>>,
+): UseMutationOptions<ChangePasswordResponse, DefaultError, Options<ChangePasswordData>> => {
+	const mutationOptions: UseMutationOptions<ChangePasswordResponse, DefaultError, Options<ChangePasswordData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await changePassword({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export const listVolumesQueryKey = (options?: Options<ListVolumesData>) => createQueryKey("listVolumes", options);
+
+/**
+ * List all volumes
+ */
+export const listVolumesOptions = (options?: Options<ListVolumesData>) =>
+	queryOptions<ListVolumesResponse, DefaultError, ListVolumesResponse, ReturnType<typeof listVolumesQueryKey>>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await listVolumes({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: listVolumesQueryKey(options),
+	});
+
+/**
+ * Create a new volume
+ */
+export const createVolumeMutation = (
+	options?: Partial<Options<CreateVolumeData>>,
+): UseMutationOptions<CreateVolumeResponse, DefaultError, Options<CreateVolumeData>> => {
+	const mutationOptions: UseMutationOptions<CreateVolumeResponse, DefaultError, Options<CreateVolumeData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await createVolume({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+/**
+ * Test connection to backend
+ */
+export const testConnectionMutation = (
+	options?: Partial<Options<TestConnectionData>>,
+): UseMutationOptions<TestConnectionResponse, DefaultError, Options<TestConnectionData>> => {
+	const mutationOptions: UseMutationOptions<TestConnectionResponse, DefaultError, Options<TestConnectionData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await testConnection({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+/**
+ * Delete a volume
+ */
+export const deleteVolumeMutation = (
+	options?: Partial<Options<DeleteVolumeData>>,
+): UseMutationOptions<DeleteVolumeResponse, DefaultError, Options<DeleteVolumeData>> => {
+	const mutationOptions: UseMutationOptions<DeleteVolumeResponse, DefaultError, Options<DeleteVolumeData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await deleteVolume({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export const getVolumeQueryKey = (options: Options<GetVolumeData>) => createQueryKey("getVolume", options);
+
+/**
+ * Get a volume by name
+ */
+export const getVolumeOptions = (options: Options<GetVolumeData>) =>
+	queryOptions<GetVolumeResponse, DefaultError, GetVolumeResponse, ReturnType<typeof getVolumeQueryKey>>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await getVolume({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: getVolumeQueryKey(options),
+	});
+
+/**
+ * Update a volume's configuration
+ */
+export const updateVolumeMutation = (
+	options?: Partial<Options<UpdateVolumeData>>,
+): UseMutationOptions<UpdateVolumeResponse, DefaultError, Options<UpdateVolumeData>> => {
+	const mutationOptions: UseMutationOptions<UpdateVolumeResponse, DefaultError, Options<UpdateVolumeData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await updateVolume({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export const getContainersUsingVolumeQueryKey = (options: Options<GetContainersUsingVolumeData>) =>
+	createQueryKey("getContainersUsingVolume", options);
+
+/**
+ * Get containers using a volume by name
+ */
+export const getContainersUsingVolumeOptions = (options: Options<GetContainersUsingVolumeData>) =>
+	queryOptions<
+		GetContainersUsingVolumeResponse,
+		DefaultError,
+		GetContainersUsingVolumeResponse,
+		ReturnType<typeof getContainersUsingVolumeQueryKey>
+	>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await getContainersUsingVolume({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: getContainersUsingVolumeQueryKey(options),
+	});
+
+/**
+ * Mount a volume
+ */
+export const mountVolumeMutation = (
+	options?: Partial<Options<MountVolumeData>>,
+): UseMutationOptions<MountVolumeResponse, DefaultError, Options<MountVolumeData>> => {
+	const mutationOptions: UseMutationOptions<MountVolumeResponse, DefaultError, Options<MountVolumeData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await mountVolume({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+/**
+ * Unmount a volume
+ */
+export const unmountVolumeMutation = (
+	options?: Partial<Options<UnmountVolumeData>>,
+): UseMutationOptions<UnmountVolumeResponse, DefaultError, Options<UnmountVolumeData>> => {
+	const mutationOptions: UseMutationOptions<UnmountVolumeResponse, DefaultError, Options<UnmountVolumeData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await unmountVolume({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+/**
+ * Perform a health check on a volume
+ */
+export const healthCheckVolumeMutation = (
+	options?: Partial<Options<HealthCheckVolumeData>>,
+): UseMutationOptions<HealthCheckVolumeResponse, DefaultError, Options<HealthCheckVolumeData>> => {
+	const mutationOptions: UseMutationOptions<HealthCheckVolumeResponse, DefaultError, Options<HealthCheckVolumeData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await healthCheckVolume({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export const listFilesQueryKey = (options: Options<ListFilesData>) => createQueryKey("listFiles", options);
+
+/**
+ * List files in a volume directory
+ */
+export const listFilesOptions = (options: Options<ListFilesData>) =>
+	queryOptions<ListFilesResponse, DefaultError, ListFilesResponse, ReturnType<typeof listFilesQueryKey>>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await listFiles({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: listFilesQueryKey(options),
+	});
+
+export const browseFilesystemQueryKey = (options?: Options<BrowseFilesystemData>) =>
+	createQueryKey("browseFilesystem", options);
+
+/**
+ * Browse directories on the host filesystem
+ */
+export const browseFilesystemOptions = (options?: Options<BrowseFilesystemData>) =>
+	queryOptions<
+		BrowseFilesystemResponse,
+		DefaultError,
+		BrowseFilesystemResponse,
+		ReturnType<typeof browseFilesystemQueryKey>
+	>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await browseFilesystem({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: browseFilesystemQueryKey(options),
+	});
+
+export const listRepositoriesQueryKey = (options?: Options<ListRepositoriesData>) =>
+	createQueryKey("listRepositories", options);
+
+/**
+ * List all repositories
+ */
+export const listRepositoriesOptions = (options?: Options<ListRepositoriesData>) =>
+	queryOptions<
+		ListRepositoriesResponse,
+		DefaultError,
+		ListRepositoriesResponse,
+		ReturnType<typeof listRepositoriesQueryKey>
+	>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await listRepositories({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: listRepositoriesQueryKey(options),
+	});
+
+/**
+ * Create a new restic repository
+ */
+export const createRepositoryMutation = (
+	options?: Partial<Options<CreateRepositoryData>>,
+): UseMutationOptions<CreateRepositoryResponse, DefaultError, Options<CreateRepositoryData>> => {
+	const mutationOptions: UseMutationOptions<CreateRepositoryResponse, DefaultError, Options<CreateRepositoryData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await createRepository({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export const listRcloneRemotesQueryKey = (options?: Options<ListRcloneRemotesData>) =>
+	createQueryKey("listRcloneRemotes", options);
+
+/**
+ * List all configured rclone remotes on the host system
+ */
+export const listRcloneRemotesOptions = (options?: Options<ListRcloneRemotesData>) =>
+	queryOptions<
+		ListRcloneRemotesResponse,
+		DefaultError,
+		ListRcloneRemotesResponse,
+		ReturnType<typeof listRcloneRemotesQueryKey>
+	>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await listRcloneRemotes({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: listRcloneRemotesQueryKey(options),
+	});
+
+/**
+ * Delete a repository
+ */
+export const deleteRepositoryMutation = (
+	options?: Partial<Options<DeleteRepositoryData>>,
+): UseMutationOptions<DeleteRepositoryResponse, DefaultError, Options<DeleteRepositoryData>> => {
+	const mutationOptions: UseMutationOptions<DeleteRepositoryResponse, DefaultError, Options<DeleteRepositoryData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await deleteRepository({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export const getRepositoryQueryKey = (options: Options<GetRepositoryData>) => createQueryKey("getRepository", options);
+
+/**
+ * Get a single repository by name
+ */
+export const getRepositoryOptions = (options: Options<GetRepositoryData>) =>
+	queryOptions<GetRepositoryResponse, DefaultError, GetRepositoryResponse, ReturnType<typeof getRepositoryQueryKey>>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await getRepository({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: getRepositoryQueryKey(options),
+	});
+
+export const listSnapshotsQueryKey = (options: Options<ListSnapshotsData>) => createQueryKey("listSnapshots", options);
+
+/**
+ * List all snapshots in a repository
+ */
+export const listSnapshotsOptions = (options: Options<ListSnapshotsData>) =>
+	queryOptions<ListSnapshotsResponse, DefaultError, ListSnapshotsResponse, ReturnType<typeof listSnapshotsQueryKey>>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await listSnapshots({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: listSnapshotsQueryKey(options),
+	});
+
+export const getSnapshotDetailsQueryKey = (options: Options<GetSnapshotDetailsData>) =>
+	createQueryKey("getSnapshotDetails", options);
+
+/**
+ * Get details of a specific snapshot
+ */
+export const getSnapshotDetailsOptions = (options: Options<GetSnapshotDetailsData>) =>
+	queryOptions<
+		GetSnapshotDetailsResponse,
+		DefaultError,
+		GetSnapshotDetailsResponse,
+		ReturnType<typeof getSnapshotDetailsQueryKey>
+	>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await getSnapshotDetails({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: getSnapshotDetailsQueryKey(options),
+	});
+
+export const listSnapshotFilesQueryKey = (options: Options<ListSnapshotFilesData>) =>
+	createQueryKey("listSnapshotFiles", options);
+
+/**
+ * List files and directories in a snapshot
+ */
+export const listSnapshotFilesOptions = (options: Options<ListSnapshotFilesData>) =>
+	queryOptions<
+		ListSnapshotFilesResponse,
+		DefaultError,
+		ListSnapshotFilesResponse,
+		ReturnType<typeof listSnapshotFilesQueryKey>
+	>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await listSnapshotFiles({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: listSnapshotFilesQueryKey(options),
+	});
+
+/**
+ * Restore a snapshot to a target path on the filesystem
+ */
+export const restoreSnapshotMutation = (
+	options?: Partial<Options<RestoreSnapshotData>>,
+): UseMutationOptions<RestoreSnapshotResponse, DefaultError, Options<RestoreSnapshotData>> => {
+	const mutationOptions: UseMutationOptions<RestoreSnapshotResponse, DefaultError, Options<RestoreSnapshotData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await restoreSnapshot({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+/**
+ * Run doctor operations on a repository to fix common issues (unlock, check, repair index). Use this when the repository is locked or has errors.
+ */
+export const doctorRepositoryMutation = (
+	options?: Partial<Options<DoctorRepositoryData>>,
+): UseMutationOptions<DoctorRepositoryResponse, DefaultError, Options<DoctorRepositoryData>> => {
+	const mutationOptions: UseMutationOptions<DoctorRepositoryResponse, DefaultError, Options<DoctorRepositoryData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await doctorRepository({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export const listBackupSchedulesQueryKey = (options?: Options<ListBackupSchedulesData>) =>
+	createQueryKey("listBackupSchedules", options);
+
+/**
+ * List all backup schedules
+ */
+export const listBackupSchedulesOptions = (options?: Options<ListBackupSchedulesData>) =>
+	queryOptions<
+		ListBackupSchedulesResponse,
+		DefaultError,
+		ListBackupSchedulesResponse,
+		ReturnType<typeof listBackupSchedulesQueryKey>
+	>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await listBackupSchedules({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: listBackupSchedulesQueryKey(options),
+	});
+
+/**
+ * Create a new backup schedule for a volume
+ */
+export const createBackupScheduleMutation = (
+	options?: Partial<Options<CreateBackupScheduleData>>,
+): UseMutationOptions<CreateBackupScheduleResponse, DefaultError, Options<CreateBackupScheduleData>> => {
+	const mutationOptions: UseMutationOptions<
+		CreateBackupScheduleResponse,
+		DefaultError,
+		Options<CreateBackupScheduleData>
+	> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await createBackupSchedule({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+/**
+ * Delete a backup schedule
+ */
+export const deleteBackupScheduleMutation = (
+	options?: Partial<Options<DeleteBackupScheduleData>>,
+): UseMutationOptions<DeleteBackupScheduleResponse, DefaultError, Options<DeleteBackupScheduleData>> => {
+	const mutationOptions: UseMutationOptions<
+		DeleteBackupScheduleResponse,
+		DefaultError,
+		Options<DeleteBackupScheduleData>
+	> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await deleteBackupSchedule({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export const getBackupScheduleQueryKey = (options: Options<GetBackupScheduleData>) =>
+	createQueryKey("getBackupSchedule", options);
+
+/**
+ * Get a backup schedule by ID
+ */
+export const getBackupScheduleOptions = (options: Options<GetBackupScheduleData>) =>
+	queryOptions<
+		GetBackupScheduleResponse,
+		DefaultError,
+		GetBackupScheduleResponse,
+		ReturnType<typeof getBackupScheduleQueryKey>
+	>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await getBackupSchedule({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: getBackupScheduleQueryKey(options),
+	});
+
+/**
+ * Update a backup schedule
+ */
+export const updateBackupScheduleMutation = (
+	options?: Partial<Options<UpdateBackupScheduleData>>,
+): UseMutationOptions<UpdateBackupScheduleResponse, DefaultError, Options<UpdateBackupScheduleData>> => {
+	const mutationOptions: UseMutationOptions<
+		UpdateBackupScheduleResponse,
+		DefaultError,
+		Options<UpdateBackupScheduleData>
+	> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await updateBackupSchedule({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export const getBackupScheduleForVolumeQueryKey = (options: Options<GetBackupScheduleForVolumeData>) =>
+	createQueryKey("getBackupScheduleForVolume", options);
+
+/**
+ * Get a backup schedule for a specific volume
+ */
+export const getBackupScheduleForVolumeOptions = (options: Options<GetBackupScheduleForVolumeData>) =>
+	queryOptions<
+		GetBackupScheduleForVolumeResponse,
+		DefaultError,
+		GetBackupScheduleForVolumeResponse,
+		ReturnType<typeof getBackupScheduleForVolumeQueryKey>
+	>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await getBackupScheduleForVolume({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: getBackupScheduleForVolumeQueryKey(options),
+	});
+
+/**
+ * Trigger a backup immediately for a schedule
+ */
+export const runBackupNowMutation = (
+	options?: Partial<Options<RunBackupNowData>>,
+): UseMutationOptions<RunBackupNowResponse, DefaultError, Options<RunBackupNowData>> => {
+	const mutationOptions: UseMutationOptions<RunBackupNowResponse, DefaultError, Options<RunBackupNowData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await runBackupNow({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+/**
+ * Stop a backup that is currently in progress
+ */
+export const stopBackupMutation = (
+	options?: Partial<Options<StopBackupData>>,
+): UseMutationOptions<StopBackupResponse, DefaultError, Options<StopBackupData>> => {
+	const mutationOptions: UseMutationOptions<StopBackupResponse, DefaultError, Options<StopBackupData>> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await stopBackup({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
+
+export const getSystemInfoQueryKey = (options?: Options<GetSystemInfoData>) => createQueryKey("getSystemInfo", options);
+
+/**
+ * Get system information including available capabilities
+ */
+export const getSystemInfoOptions = (options?: Options<GetSystemInfoData>) =>
+	queryOptions<GetSystemInfoResponse, DefaultError, GetSystemInfoResponse, ReturnType<typeof getSystemInfoQueryKey>>({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await getSystemInfo({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: getSystemInfoQueryKey(options),
+	});
+
+/**
+ * Download the Restic password file for backup recovery. Requires password re-authentication.
+ */
+export const downloadResticPasswordMutation = (
+	options?: Partial<Options<DownloadResticPasswordData>>,
+): UseMutationOptions<DownloadResticPasswordResponse, DefaultError, Options<DownloadResticPasswordData>> => {
+	const mutationOptions: UseMutationOptions<
+		DownloadResticPasswordResponse,
+		DefaultError,
+		Options<DownloadResticPasswordData>
+	> = {
+		mutationFn: async (fnOptions) => {
+			const { data } = await downloadResticPassword({
+				...options,
+				...fnOptions,
+				throwOnError: true,
+			});
+			return data;
+		},
+	};
+	return mutationOptions;
+};
--- a/app/client/api-client/client.gen.ts
+++ b/app/client/api-client/client.gen.ts
@@ -0,0 +1,22 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { type ClientOptions, type Config, createClient, createConfig } from "./client";
+import type { ClientOptions as ClientOptions2 } from "./types.gen";
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (
+	override?: Config<ClientOptions & T>,
+) => Config<Required<ClientOptions> & T>;
+
+export const client = createClient(
+	createConfig<ClientOptions2>({
+		baseUrl: "http://192.168.2.42:4096",
+	}),
+);
--- a/app/client/api-client/client/client.gen.ts
+++ b/app/client/api-client/client/client.gen.ts
@@ -0,0 +1,278 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createSseClient } from "../core/serverSentEvents.gen";
+import type { HttpMethod } from "../core/types.gen";
+import { getValidRequestBody } from "../core/utils.gen";
+import type { Client, Config, RequestOptions, ResolvedRequestOptions } from "./types.gen";
+import {
+	buildUrl,
+	createConfig,
+	createInterceptors,
+	getParseAs,
+	mergeConfigs,
+	mergeHeaders,
+	setAuthParams,
+} from "./utils.gen";
+
+type ReqInit = Omit<RequestInit, "body" | "headers"> & {
+	body?: any;
+	headers: ReturnType<typeof mergeHeaders>;
+};
+
+export const createClient = (config: Config = {}): Client => {
+	let _config = mergeConfigs(createConfig(), config);
+
+	const getConfig = (): Config => ({ ..._config });
+
+	const setConfig = (config: Config): Config => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+
+	const interceptors = createInterceptors<Request, Response, unknown, ResolvedRequestOptions>();
+
+	const beforeRequest = async (options: RequestOptions) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: undefined,
+		};
+
+		if (opts.security) {
+			await setAuthParams({
+				...opts,
+				security: opts.security,
+			});
+		}
+
+		if (opts.requestValidator) {
+			await opts.requestValidator(opts);
+		}
+
+		if (opts.body !== undefined && opts.bodySerializer) {
+			opts.serializedBody = opts.bodySerializer(opts.body);
+		}
+
+		// remove Content-Type header if body is empty to avoid sending invalid requests
+		if (opts.body === undefined || opts.serializedBody === "") {
+			opts.headers.delete("Content-Type");
+		}
+
+		const url = buildUrl(opts);
+
+		return { opts, url };
+	};
+
+	const request: Client["request"] = async (options) => {
+		// @ts-expect-error
+		const { opts, url } = await beforeRequest(options);
+		const requestInit: ReqInit = {
+			redirect: "follow",
+			...opts,
+			body: getValidRequestBody(opts),
+		};
+
+		let request = new Request(url, requestInit);
+
+		for (const fn of interceptors.request.fns) {
+			if (fn) {
+				request = await fn(request, opts);
+			}
+		}
+
+		// fetch must be assigned here, otherwise it would throw the error:
+		// TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+		const _fetch = opts.fetch!;
+		let response: Response;
+
+		try {
+			response = await _fetch(request);
+		} catch (error) {
+			// Handle fetch exceptions (AbortError, network errors, etc.)
+			let finalError = error;
+
+			for (const fn of interceptors.error.fns) {
+				if (fn) {
+					finalError = (await fn(error, undefined as any, request, opts)) as unknown;
+				}
+			}
+
+			finalError = finalError || ({} as unknown);
+
+			if (opts.throwOnError) {
+				throw finalError;
+			}
+
+			// Return error response
+			return opts.responseStyle === "data"
+				? undefined
+				: {
+						error: finalError,
+						request,
+						response: undefined as any,
+					};
+		}
+
+		for (const fn of interceptors.response.fns) {
+			if (fn) {
+				response = await fn(response, request, opts);
+			}
+		}
+
+		const result = {
+			request,
+			response,
+		};
+
+		if (response.ok) {
+			const parseAs =
+				(opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+
+			if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+				let emptyData: any;
+				switch (parseAs) {
+					case "arrayBuffer":
+					case "blob":
+					case "text":
+						emptyData = await response[parseAs]();
+						break;
+					case "formData":
+						emptyData = new FormData();
+						break;
+					case "stream":
+						emptyData = response.body;
+						break;
+					case "json":
+					default:
+						emptyData = {};
+						break;
+				}
+				return opts.responseStyle === "data"
+					? emptyData
+					: {
+							data: emptyData,
+							...result,
+						};
+			}
+
+			let data: any;
+			switch (parseAs) {
+				case "arrayBuffer":
+				case "blob":
+				case "formData":
+				case "json":
+				case "text":
+					data = await response[parseAs]();
+					break;
+				case "stream":
+					return opts.responseStyle === "data"
+						? response.body
+						: {
+								data: response.body,
+								...result,
+							};
+			}
+
+			if (parseAs === "json") {
+				if (opts.responseValidator) {
+					await opts.responseValidator(data);
+				}
+
+				if (opts.responseTransformer) {
+					data = await opts.responseTransformer(data);
+				}
+			}
+
+			return opts.responseStyle === "data"
+				? data
+				: {
+						data,
+						...result,
+					};
+		}
+
+		const textError = await response.text();
+		let jsonError: unknown;
+
+		try {
+			jsonError = JSON.parse(textError);
+		} catch {
+			// noop
+		}
+
+		const error = jsonError ?? textError;
+		let finalError = error;
+
+		for (const fn of interceptors.error.fns) {
+			if (fn) {
+				finalError = (await fn(error, response, request, opts)) as string;
+			}
+		}
+
+		finalError = finalError || ({} as string);
+
+		if (opts.throwOnError) {
+			throw finalError;
+		}
+
+		// TODO: we probably want to return error and improve types
+		return opts.responseStyle === "data"
+			? undefined
+			: {
+					error: finalError,
+					...result,
+				};
+	};
+
+	const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) => request({ ...options, method });
+
+	const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body as BodyInit | null | undefined,
+			headers: opts.headers as unknown as Record<string, string>,
+			method,
+			onRequest: async (url, init) => {
+				let request = new Request(url, init);
+				for (const fn of interceptors.request.fns) {
+					if (fn) {
+						request = await fn(request, opts);
+					}
+				}
+				return request;
+			},
+			url,
+		});
+	};
+
+	return {
+		buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		interceptors,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE"),
+		},
+		trace: makeMethodFn("TRACE"),
+	} as Client;
+};
--- a/app/client/api-client/client/index.ts
+++ b/app/client/api-client/client/index.ts
@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from "../core/auth.gen";
+export type { QuerySerializerOptions } from "../core/bodySerializer.gen";
+export {
+	formDataBodySerializer,
+	jsonBodySerializer,
+	urlSearchParamsBodySerializer,
+} from "../core/bodySerializer.gen";
+export { buildClientParams } from "../core/params.gen";
+export { serializeQueryKeyValue } from "../core/queryKeySerializer.gen";
+export { createClient } from "./client.gen";
+export type {
+	Client,
+	ClientOptions,
+	Config,
+	CreateClientConfig,
+	Options,
+	RequestOptions,
+	RequestResult,
+	ResolvedRequestOptions,
+	ResponseStyle,
+	TDataShape,
+} from "./types.gen";
+export { createConfig, mergeHeaders } from "./utils.gen";
--- a/app/client/api-client/client/types.gen.ts
+++ b/app/client/api-client/client/types.gen.ts
@@ -0,0 +1,202 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Auth } from "../core/auth.gen";
+import type { ServerSentEventsOptions, ServerSentEventsResult } from "../core/serverSentEvents.gen";
+import type { Client as CoreClient, Config as CoreConfig } from "../core/types.gen";
+import type { Middleware } from "./utils.gen";
+
+export type ResponseStyle = "data" | "fields";
+
+export interface Config<T extends ClientOptions = ClientOptions>
+	extends Omit<RequestInit, "body" | "headers" | "method">,
+		CoreConfig {
+	/**
+	 * Base URL for all requests made by this client.
+	 */
+	baseUrl?: T["baseUrl"];
+	/**
+	 * Fetch API implementation. You can use this option to provide a custom
+	 * fetch instance.
+	 *
+	 * @default globalThis.fetch
+	 */
+	fetch?: typeof fetch;
+	/**
+	 * Please don't use the Fetch client for Next.js applications. The `next`
+	 * options won't have any effect.
+	 *
+	 * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+	 */
+	next?: never;
+	/**
+	 * Return the response data parsed in a specified format. By default, `auto`
+	 * will infer the appropriate method from the `Content-Type` response header.
+	 * You can override this behavior with any of the {@link Body} methods.
+	 * Select `stream` if you don't want to parse response data at all.
+	 *
+	 * @default 'auto'
+	 */
+	parseAs?: "arrayBuffer" | "auto" | "blob" | "formData" | "json" | "stream" | "text";
+	/**
+	 * Should we return only data or multiple fields (data, error, response, etc.)?
+	 *
+	 * @default 'fields'
+	 */
+	responseStyle?: ResponseStyle;
+	/**
+	 * Throw an error instead of returning it in the response?
+	 *
+	 * @default false
+	 */
+	throwOnError?: T["throwOnError"];
+}
+
+export interface RequestOptions<
+	TData = unknown,
+	TResponseStyle extends ResponseStyle = "fields",
+	ThrowOnError extends boolean = boolean,
+	Url extends string = string,
+> extends Config<{
+			responseStyle: TResponseStyle;
+			throwOnError: ThrowOnError;
+		}>,
+		Pick<
+			ServerSentEventsOptions<TData>,
+			"onSseError" | "onSseEvent" | "sseDefaultRetryDelay" | "sseMaxRetryAttempts" | "sseMaxRetryDelay"
+		> {
+	/**
+	 * Any body that you want to add to your request.
+	 *
+	 * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+	 */
+	body?: unknown;
+	path?: Record<string, unknown>;
+	query?: Record<string, unknown>;
+	/**
+	 * Security mechanism(s) to use for the request.
+	 */
+	security?: ReadonlyArray<Auth>;
+	url: Url;
+}
+
+export interface ResolvedRequestOptions<
+	TResponseStyle extends ResponseStyle = "fields",
+	ThrowOnError extends boolean = boolean,
+	Url extends string = string,
+> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+	serializedBody?: string;
+}
+
+export type RequestResult<
+	TData = unknown,
+	TError = unknown,
+	ThrowOnError extends boolean = boolean,
+	TResponseStyle extends ResponseStyle = "fields",
+> = ThrowOnError extends true
+	? Promise<
+			TResponseStyle extends "data"
+				? TData extends Record<string, unknown>
+					? TData[keyof TData]
+					: TData
+				: {
+						data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+						request: Request;
+						response: Response;
+					}
+		>
+	: Promise<
+			TResponseStyle extends "data"
+				? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined
+				: (
+						| {
+								data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+								error: undefined;
+						  }
+						| {
+								data: undefined;
+								error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+						  }
+					) & {
+						request: Request;
+						response: Response;
+					}
+		>;
+
+export interface ClientOptions {
+	baseUrl?: string;
+	responseStyle?: ResponseStyle;
+	throwOnError?: boolean;
+}
+
+type MethodFn = <
+	TData = unknown,
+	TError = unknown,
+	ThrowOnError extends boolean = false,
+	TResponseStyle extends ResponseStyle = "fields",
+>(
+	options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">,
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+
+type SseFn = <
+	TData = unknown,
+	TError = unknown,
+	ThrowOnError extends boolean = false,
+	TResponseStyle extends ResponseStyle = "fields",
+>(
+	options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">,
+) => Promise<ServerSentEventsResult<TData, TError>>;
+
+type RequestFn = <
+	TData = unknown,
+	TError = unknown,
+	ThrowOnError extends boolean = false,
+	TResponseStyle extends ResponseStyle = "fields",
+>(
+	options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> &
+		Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">,
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+
+type BuildUrlFn = <
+	TData extends {
+		body?: unknown;
+		path?: Record<string, unknown>;
+		query?: Record<string, unknown>;
+		url: string;
+	},
+>(
+	options: TData & Options<TData>,
+) => string;
+
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+	interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
+	override?: Config<ClientOptions & T>,
+) => Config<Required<ClientOptions> & T>;
+
+export interface TDataShape {
+	body?: unknown;
+	headers?: unknown;
+	path?: unknown;
+	query?: unknown;
+	url: string;
+}
+
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+
+export type Options<
+	TData extends TDataShape = TDataShape,
+	ThrowOnError extends boolean = boolean,
+	TResponse = unknown,
+	TResponseStyle extends ResponseStyle = "fields",
+> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, "body" | "path" | "query" | "url"> &
+	([TData] extends [never] ? unknown : Omit<TData, "url">);
--- a/app/client/api-client/client/utils.gen.ts
+++ b/app/client/api-client/client/utils.gen.ts
@@ -0,0 +1,289 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { getAuthToken } from "../core/auth.gen";
+import type { QuerySerializerOptions } from "../core/bodySerializer.gen";
+import { jsonBodySerializer } from "../core/bodySerializer.gen";
+import { serializeArrayParam, serializeObjectParam, serializePrimitiveParam } from "../core/pathSerializer.gen";
+import { getUrl } from "../core/utils.gen";
+import type { Client, ClientOptions, Config, RequestOptions } from "./types.gen";
+
+export const createQuerySerializer = <T = unknown>({ parameters = {}, ...args }: QuerySerializerOptions = {}) => {
+	const querySerializer = (queryParams: T) => {
+		const search: string[] = [];
+		if (queryParams && typeof queryParams === "object") {
+			for (const name in queryParams) {
+				const value = queryParams[name];
+
+				if (value === undefined || value === null) {
+					continue;
+				}
+
+				const options = parameters[name] || args;
+
+				if (Array.isArray(value)) {
+					const serializedArray = serializeArrayParam({
+						allowReserved: options.allowReserved,
+						explode: true,
+						name,
+						style: "form",
+						value,
+						...options.array,
+					});
+					if (serializedArray) search.push(serializedArray);
+				} else if (typeof value === "object") {
+					const serializedObject = serializeObjectParam({
+						allowReserved: options.allowReserved,
+						explode: true,
+						name,
+						style: "deepObject",
+						value: value as Record<string, unknown>,
+						...options.object,
+					});
+					if (serializedObject) search.push(serializedObject);
+				} else {
+					const serializedPrimitive = serializePrimitiveParam({
+						allowReserved: options.allowReserved,
+						name,
+						value: value as string,
+					});
+					if (serializedPrimitive) search.push(serializedPrimitive);
+				}
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+
+/**
+ * Infers parseAs value from provided Content-Type header.
+ */
+export const getParseAs = (contentType: string | null): Exclude<Config["parseAs"], "auto"> => {
+	if (!contentType) {
+		// If no Content-Type header is provided, the best we can do is return the raw response body,
+		// which is effectively the same as the 'stream' option.
+		return "stream";
+	}
+
+	const cleanContent = contentType.split(";")[0]?.trim();
+
+	if (!cleanContent) {
+		return;
+	}
+
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+		return "json";
+	}
+
+	if (cleanContent === "multipart/form-data") {
+		return "formData";
+	}
+
+	if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
+		return "blob";
+	}
+
+	if (cleanContent.startsWith("text/")) {
+		return "text";
+	}
+
+	return;
+};
+
+const checkForExistence = (
+	options: Pick<RequestOptions, "auth" | "query"> & {
+		headers: Headers;
+	},
+	name?: string,
+): boolean => {
+	if (!name) {
+		return false;
+	}
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+		return true;
+	}
+	return false;
+};
+
+export const setAuthParams = async ({
+	security,
+	...options
+}: Pick<Required<RequestOptions>, "security"> &
+	Pick<RequestOptions, "auth" | "query"> & {
+		headers: Headers;
+	}) => {
+	for (const auth of security) {
+		if (checkForExistence(options, auth.name)) {
+			continue;
+		}
+
+		const token = await getAuthToken(auth, options.auth);
+
+		if (!token) {
+			continue;
+		}
+
+		const name = auth.name ?? "Authorization";
+
+		switch (auth.in) {
+			case "query":
+				if (!options.query) {
+					options.query = {};
+				}
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			case "header":
+			default:
+				options.headers.set(name, token);
+				break;
+		}
+	}
+};
+
+export const buildUrl: Client["buildUrl"] = (options) =>
+	getUrl({
+		baseUrl: options.baseUrl as string,
+		path: options.path,
+		query: options.query,
+		querySerializer:
+			typeof options.querySerializer === "function"
+				? options.querySerializer
+				: createQuerySerializer(options.querySerializer),
+		url: options.url,
+	});
+
+export const mergeConfigs = (a: Config, b: Config): Config => {
+	const config = { ...a, ...b };
+	if (config.baseUrl?.endsWith("/")) {
+		config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	}
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+
+const headersEntries = (headers: Headers): Array<[string, string]> => {
+	const entries: Array<[string, string]> = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+
+export const mergeHeaders = (...headers: Array<Required<Config>["headers"] | undefined>): Headers => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) {
+			continue;
+		}
+
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+
+		for (const [key, value] of iterator) {
+			if (value === null) {
+				mergedHeaders.delete(key);
+			} else if (Array.isArray(value)) {
+				for (const v of value) {
+					mergedHeaders.append(key, v as string);
+				}
+			} else if (value !== undefined) {
+				// assume object headers are meant to be JSON stringified, i.e. their
+				// content value in OpenAPI specification is 'application/json'
+				mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : (value as string));
+			}
+		}
+	}
+	return mergedHeaders;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (
+	error: Err,
+	response: Res,
+	request: Req,
+	options: Options,
+) => Err | Promise<Err>;
+
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+
+class Interceptors<Interceptor> {
+	fns: Array<Interceptor | null> = [];
+
+	clear(): void {
+		this.fns = [];
+	}
+
+	eject(id: number | Interceptor): void {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = null;
+		}
+	}
+
+	exists(id: number | Interceptor): boolean {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+
+	getInterceptorIndex(id: number | Interceptor): number {
+		if (typeof id === "number") {
+			return this.fns[id] ? id : -1;
+		}
+		return this.fns.indexOf(id);
+	}
+
+	update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+
+	use(fn: Interceptor): number {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+}
+
+export interface Middleware<Req, Res, Err, Options> {
+	error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+	request: Interceptors<ReqInterceptor<Req, Options>>;
+	response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+export const createInterceptors = <Req, Res, Err, Options>(): Middleware<Req, Res, Err, Options> => ({
+	error: new Interceptors<ErrInterceptor<Err, Res, Req, Options>>(),
+	request: new Interceptors<ReqInterceptor<Req, Options>>(),
+	response: new Interceptors<ResInterceptor<Res, Req, Options>>(),
+});
+
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form",
+	},
+	object: {
+		explode: true,
+		style: "deepObject",
+	},
+});
+
+const defaultHeaders = {
+	"Content-Type": "application/json",
+};
+
+export const createConfig = <T extends ClientOptions = ClientOptions>(
+	override: Config<Omit<ClientOptions, keyof T> & T> = {},
+): Config<Omit<ClientOptions, keyof T> & T> => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override,
+});
--- a/app/client/api-client/core/auth.gen.ts
+++ b/app/client/api-client/core/auth.gen.ts
@@ -0,0 +1,41 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type AuthToken = string | undefined;
+
+export interface Auth {
+	/**
+	 * Which part of the request do we use to send the auth?
+	 *
+	 * @default 'header'
+	 */
+	in?: "header" | "query" | "cookie";
+	/**
+	 * Header or query parameter name.
+	 *
+	 * @default 'Authorization'
+	 */
+	name?: string;
+	scheme?: "basic" | "bearer";
+	type: "apiKey" | "http";
+}
+
+export const getAuthToken = async (
+	auth: Auth,
+	callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken,
+): Promise<string | undefined> => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+
+	if (!token) {
+		return;
+	}
+
+	if (auth.scheme === "bearer") {
+		return `Bearer ${token}`;
+	}
+
+	if (auth.scheme === "basic") {
+		return `Basic ${btoa(token)}`;
+	}
+
+	return token;
+};
--- a/app/client/api-client/core/bodySerializer.gen.ts
+++ b/app/client/api-client/core/bodySerializer.gen.ts
@@ -0,0 +1,82 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { ArrayStyle, ObjectStyle, SerializerOptions } from "./pathSerializer.gen";
+
+export type QuerySerializer = (query: Record<string, unknown>) => string;
+
+export type BodySerializer = (body: any) => any;
+
+type QuerySerializerOptionsObject = {
+	allowReserved?: boolean;
+	array?: Partial<SerializerOptions<ArrayStyle>>;
+	object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+
+export type QuerySerializerOptions = QuerySerializerOptionsObject & {
+	/**
+	 * Per-parameter serialization overrides. When provided, these settings
+	 * override the global array/object settings for specific parameter names.
+	 */
+	parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+const serializeFormDataPair = (data: FormData, key: string, value: unknown): void => {
+	if (typeof value === "string" || value instanceof Blob) {
+		data.append(key, value);
+	} else if (value instanceof Date) {
+		data.append(key, value.toISOString());
+	} else {
+		data.append(key, JSON.stringify(value));
+	}
+};
+
+const serializeUrlSearchParamsPair = (data: URLSearchParams, key: string, value: unknown): void => {
+	if (typeof value === "string") {
+		data.append(key, value);
+	} else {
+		data.append(key, JSON.stringify(value));
+	}
+};
+
+export const formDataBodySerializer = {
+	bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T): FormData => {
+		const data = new FormData();
+
+		Object.entries(body).forEach(([key, value]) => {
+			if (value === undefined || value === null) {
+				return;
+			}
+			if (Array.isArray(value)) {
+				value.forEach((v) => serializeFormDataPair(data, key, v));
+			} else {
+				serializeFormDataPair(data, key, value);
+			}
+		});
+
+		return data;
+	},
+};
+
+export const jsonBodySerializer = {
+	bodySerializer: <T>(body: T): string =>
+		JSON.stringify(body, (_key, value) => (typeof value === "bigint" ? value.toString() : value)),
+};
+
+export const urlSearchParamsBodySerializer = {
+	bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T): string => {
+		const data = new URLSearchParams();
+
+		Object.entries(body).forEach(([key, value]) => {
+			if (value === undefined || value === null) {
+				return;
+			}
+			if (Array.isArray(value)) {
+				value.forEach((v) => serializeUrlSearchParamsPair(data, key, v));
+			} else {
+				serializeUrlSearchParamsPair(data, key, value);
+			}
+		});
+
+		return data.toString();
+	},
+};
--- a/app/client/api-client/core/params.gen.ts
+++ b/app/client/api-client/core/params.gen.ts
@@ -0,0 +1,169 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+type Slot = "body" | "headers" | "path" | "query";
+
+export type Field =
+	| {
+			in: Exclude<Slot, "body">;
+			/**
+			 * Field name. This is the name we want the user to see and use.
+			 */
+			key: string;
+			/**
+			 * Field mapped name. This is the name we want to use in the request.
+			 * If omitted, we use the same value as `key`.
+			 */
+			map?: string;
+	  }
+	| {
+			in: Extract<Slot, "body">;
+			/**
+			 * Key isn't required for bodies.
+			 */
+			key?: string;
+			map?: string;
+	  }
+	| {
+			/**
+			 * Field name. This is the name we want the user to see and use.
+			 */
+			key: string;
+			/**
+			 * Field mapped name. This is the name we want to use in the request.
+			 * If `in` is omitted, `map` aliases `key` to the transport layer.
+			 */
+			map: Slot;
+	  };
+
+export interface Fields {
+	allowExtra?: Partial<Record<Slot, boolean>>;
+	args?: ReadonlyArray<Field>;
+}
+
+export type FieldsConfig = ReadonlyArray<Field | Fields>;
+
+const extraPrefixesMap: Record<string, Slot> = {
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query",
+};
+const extraPrefixes = Object.entries(extraPrefixesMap);
+
+type KeyMap = Map<
+	string,
+	| {
+			in: Slot;
+			map?: string;
+	  }
+	| {
+			in?: never;
+			map: Slot;
+	  }
+>;
+
+const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
+	if (!map) {
+		map = new Map();
+	}
+
+	for (const config of fields) {
+		if ("in" in config) {
+			if (config.key) {
+				map.set(config.key, {
+					in: config.in,
+					map: config.map,
+				});
+			}
+		} else if ("key" in config) {
+			map.set(config.key, {
+				map: config.map,
+			});
+		} else if (config.args) {
+			buildKeyMap(config.args, map);
+		}
+	}
+
+	return map;
+};
+
+interface Params {
+	body: unknown;
+	headers: Record<string, unknown>;
+	path: Record<string, unknown>;
+	query: Record<string, unknown>;
+}
+
+const stripEmptySlots = (params: Params) => {
+	for (const [slot, value] of Object.entries(params)) {
+		if (value && typeof value === "object" && !Object.keys(value).length) {
+			delete params[slot as Slot];
+		}
+	}
+};
+
+export const buildClientParams = (args: ReadonlyArray<unknown>, fields: FieldsConfig) => {
+	const params: Params = {
+		body: {},
+		headers: {},
+		path: {},
+		query: {},
+	};
+
+	const map = buildKeyMap(fields);
+
+	let config: FieldsConfig[number] | undefined;
+
+	for (const [index, arg] of args.entries()) {
+		if (fields[index]) {
+			config = fields[index];
+		}
+
+		if (!config) {
+			continue;
+		}
+
+		if ("in" in config) {
+			if (config.key) {
+				const field = map.get(config.key)!;
+				const name = field.map || config.key;
+				if (field.in) {
+					(params[field.in] as Record<string, unknown>)[name] = arg;
+				}
+			} else {
+				params.body = arg;
+			}
+		} else {
+			for (const [key, value] of Object.entries(arg ?? {})) {
+				const field = map.get(key);
+
+				if (field) {
+					if (field.in) {
+						const name = field.map || key;
+						(params[field.in] as Record<string, unknown>)[name] = value;
+					} else {
+						params[field.map] = value;
+					}
+				} else {
+					const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
+
+					if (extra) {
+						const [prefix, slot] = extra;
+						(params[slot] as Record<string, unknown>)[key.slice(prefix.length)] = value;
+					} else if ("allowExtra" in config && config.allowExtra) {
+						for (const [slot, allowed] of Object.entries(config.allowExtra)) {
+							if (allowed) {
+								(params[slot as Slot] as Record<string, unknown>)[key] = value;
+								break;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	stripEmptySlots(params);
+
+	return params;
+};
--- a/app/client/api-client/core/pathSerializer.gen.ts
+++ b/app/client/api-client/core/pathSerializer.gen.ts
@@ -0,0 +1,167 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+interface SerializeOptions<T> extends SerializePrimitiveOptions, SerializerOptions<T> {}
+
+interface SerializePrimitiveOptions {
+	allowReserved?: boolean;
+	name: string;
+}
+
+export interface SerializerOptions<T> {
+	/**
+	 * @default true
+	 */
+	explode: boolean;
+	style: T;
+}
+
+export type ArrayStyle = "form" | "spaceDelimited" | "pipeDelimited";
+export type ArraySeparatorStyle = ArrayStyle | MatrixStyle;
+type MatrixStyle = "label" | "matrix" | "simple";
+export type ObjectStyle = "form" | "deepObject";
+type ObjectSeparatorStyle = ObjectStyle | MatrixStyle;
+
+interface SerializePrimitiveParam extends SerializePrimitiveOptions {
+	value: string;
+}
+
+export const separatorArrayExplode = (style: ArraySeparatorStyle) => {
+	switch (style) {
+		case "label":
+			return ".";
+		case "matrix":
+			return ";";
+		case "simple":
+			return ",";
+		default:
+			return "&";
+	}
+};
+
+export const separatorArrayNoExplode = (style: ArraySeparatorStyle) => {
+	switch (style) {
+		case "form":
+			return ",";
+		case "pipeDelimited":
+			return "|";
+		case "spaceDelimited":
+			return "%20";
+		default:
+			return ",";
+	}
+};
+
+export const separatorObjectExplode = (style: ObjectSeparatorStyle) => {
+	switch (style) {
+		case "label":
+			return ".";
+		case "matrix":
+			return ";";
+		case "simple":
+			return ",";
+		default:
+			return "&";
+	}
+};
+
+export const serializeArrayParam = ({
+	allowReserved,
+	explode,
+	name,
+	style,
+	value,
+}: SerializeOptions<ArraySeparatorStyle> & {
+	value: unknown[];
+}) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v as string))).join(
+			separatorArrayNoExplode(style),
+		);
+		switch (style) {
+			case "label":
+				return `.${joinedValues}`;
+			case "matrix":
+				return `;${name}=${joinedValues}`;
+			case "simple":
+				return joinedValues;
+			default:
+				return `${name}=${joinedValues}`;
+		}
+	}
+
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value
+		.map((v) => {
+			if (style === "label" || style === "simple") {
+				return allowReserved ? v : encodeURIComponent(v as string);
+			}
+
+			return serializePrimitiveParam({
+				allowReserved,
+				name,
+				value: v as string,
+			});
+		})
+		.join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+export const serializePrimitiveParam = ({ allowReserved, name, value }: SerializePrimitiveParam) => {
+	if (value === undefined || value === null) {
+		return "";
+	}
+
+	if (typeof value === "object") {
+		throw new Error(
+			"Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.",
+		);
+	}
+
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+
+export const serializeObjectParam = ({
+	allowReserved,
+	explode,
+	name,
+	style,
+	value,
+	valueOnly,
+}: SerializeOptions<ObjectSeparatorStyle> & {
+	value: Record<string, unknown> | Date;
+	valueOnly?: boolean;
+}) => {
+	if (value instanceof Date) {
+		return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	}
+
+	if (style !== "deepObject" && !explode) {
+		let values: string[] = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [...values, key, allowReserved ? (v as string) : encodeURIComponent(v as string)];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form":
+				return `${name}=${joinedValues}`;
+			case "label":
+				return `.${joinedValues}`;
+			case "matrix":
+				return `;${name}=${joinedValues}`;
+			default:
+				return joinedValues;
+		}
+	}
+
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value)
+		.map(([key, v]) =>
+			serializePrimitiveParam({
+				allowReserved,
+				name: style === "deepObject" ? `${name}[${key}]` : key,
+				value: v as string,
+			}),
+		)
+		.join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
--- a/app/client/api-client/core/queryKeySerializer.gen.ts
+++ b/app/client/api-client/core/queryKeySerializer.gen.ts
@@ -0,0 +1,111 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+/**
+ * JSON-friendly union that mirrors what Pinia Colada can hash.
+ */
+export type JsonValue = null | string | number | boolean | JsonValue[] | { [key: string]: JsonValue };
+
+/**
+ * Replacer that converts non-JSON values (bigint, Date, etc.) to safe substitutes.
+ */
+export const queryKeyJsonReplacer = (_key: string, value: unknown) => {
+	if (value === undefined || typeof value === "function" || typeof value === "symbol") {
+		return undefined;
+	}
+	if (typeof value === "bigint") {
+		return value.toString();
+	}
+	if (value instanceof Date) {
+		return value.toISOString();
+	}
+	return value;
+};
+
+/**
+ * Safely stringifies a value and parses it back into a JsonValue.
+ */
+export const stringifyToJsonValue = (input: unknown): JsonValue | undefined => {
+	try {
+		const json = JSON.stringify(input, queryKeyJsonReplacer);
+		if (json === undefined) {
+			return undefined;
+		}
+		return JSON.parse(json) as JsonValue;
+	} catch {
+		return undefined;
+	}
+};
+
+/**
+ * Detects plain objects (including objects with a null prototype).
+ */
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+	if (value === null || typeof value !== "object") {
+		return false;
+	}
+	const prototype = Object.getPrototypeOf(value as object);
+	return prototype === Object.prototype || prototype === null;
+};
+
+/**
+ * Turns URLSearchParams into a sorted JSON object for deterministic keys.
+ */
+const serializeSearchParams = (params: URLSearchParams): JsonValue => {
+	const entries = Array.from(params.entries()).sort(([a], [b]) => a.localeCompare(b));
+	const result: Record<string, JsonValue> = {};
+
+	for (const [key, value] of entries) {
+		const existing = result[key];
+		if (existing === undefined) {
+			result[key] = value;
+			continue;
+		}
+
+		if (Array.isArray(existing)) {
+			(existing as string[]).push(value);
+		} else {
+			result[key] = [existing, value];
+		}
+	}
+
+	return result;
+};
+
+/**
+ * Normalizes any accepted value into a JSON-friendly shape for query keys.
+ */
+export const serializeQueryKeyValue = (value: unknown): JsonValue | undefined => {
+	if (value === null) {
+		return null;
+	}
+
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+		return value;
+	}
+
+	if (value === undefined || typeof value === "function" || typeof value === "symbol") {
+		return undefined;
+	}
+
+	if (typeof value === "bigint") {
+		return value.toString();
+	}
+
+	if (value instanceof Date) {
+		return value.toISOString();
+	}
+
+	if (Array.isArray(value)) {
+		return stringifyToJsonValue(value);
+	}
+
+	if (typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams) {
+		return serializeSearchParams(value);
+	}
+
+	if (isPlainObject(value)) {
+		return stringifyToJsonValue(value);
+	}
+
+	return undefined;
+};
--- a/app/client/api-client/core/serverSentEvents.gen.ts
+++ b/app/client/api-client/core/serverSentEvents.gen.ts
@@ -0,0 +1,237 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Config } from "./types.gen";
+
+export type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, "method"> &
+	Pick<Config, "method" | "responseTransformer" | "responseValidator"> & {
+		/**
+		 * Fetch API implementation. You can use this option to provide a custom
+		 * fetch instance.
+		 *
+		 * @default globalThis.fetch
+		 */
+		fetch?: typeof fetch;
+		/**
+		 * Implementing clients can call request interceptors inside this hook.
+		 */
+		onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+		/**
+		 * Callback invoked when a network or parsing error occurs during streaming.
+		 *
+		 * This option applies only if the endpoint returns a stream of events.
+		 *
+		 * @param error The error that occurred.
+		 */
+		onSseError?: (error: unknown) => void;
+		/**
+		 * Callback invoked when an event is streamed from the server.
+		 *
+		 * This option applies only if the endpoint returns a stream of events.
+		 *
+		 * @param event Event streamed from the server.
+		 * @returns Nothing (void).
+		 */
+		onSseEvent?: (event: StreamEvent<TData>) => void;
+		serializedBody?: RequestInit["body"];
+		/**
+		 * Default retry delay in milliseconds.
+		 *
+		 * This option applies only if the endpoint returns a stream of events.
+		 *
+		 * @default 3000
+		 */
+		sseDefaultRetryDelay?: number;
+		/**
+		 * Maximum number of retry attempts before giving up.
+		 */
+		sseMaxRetryAttempts?: number;
+		/**
+		 * Maximum retry delay in milliseconds.
+		 *
+		 * Applies only when exponential backoff is used.
+		 *
+		 * This option applies only if the endpoint returns a stream of events.
+		 *
+		 * @default 30000
+		 */
+		sseMaxRetryDelay?: number;
+		/**
+		 * Optional sleep function for retry backoff.
+		 *
+		 * Defaults to using `setTimeout`.
+		 */
+		sseSleepFn?: (ms: number) => Promise<void>;
+		url: string;
+	};
+
+export interface StreamEvent<TData = unknown> {
+	data: TData;
+	event?: string;
+	id?: string;
+	retry?: number;
+}
+
+export type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+	stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+export const createSseClient = <TData = unknown>({
+	onRequest,
+	onSseError,
+	onSseEvent,
+	responseTransformer,
+	responseValidator,
+	sseDefaultRetryDelay,
+	sseMaxRetryAttempts,
+	sseMaxRetryDelay,
+	sseSleepFn,
+	url,
+	...options
+}: ServerSentEventsOptions): ServerSentEventsResult<TData> => {
+	let lastEventId: string | undefined;
+
+	const sleep = sseSleepFn ?? ((ms: number) => new Promise((resolve) => setTimeout(resolve, ms)));
+
+	const createStream = async function* () {
+		let retryDelay: number = sseDefaultRetryDelay ?? 3000;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+
+		while (true) {
+			if (signal.aborted) break;
+
+			attempt++;
+
+			const headers =
+				options.headers instanceof Headers
+					? options.headers
+					: new Headers(options.headers as Record<string, string> | undefined);
+
+			if (lastEventId !== undefined) {
+				headers.set("Last-Event-ID", lastEventId);
+			}
+
+			try {
+				const requestInit: RequestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal,
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) {
+					request = await onRequest(url, requestInit);
+				}
+				// fetch must be assigned here, otherwise it would throw the error:
+				// TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+				const _fetch = options.fetch ?? globalThis.fetch;
+				const response = await _fetch(request);
+
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+
+				if (!response.body) throw new Error("No body in SSE response");
+
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+
+				let buffer = "";
+
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {
+						// noop
+					}
+				};
+
+				signal.addEventListener("abort", abortHandler);
+
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines: Array<string> = [];
+							let eventName: string | undefined;
+
+							for (const line of lines) {
+								if (line.startsWith("data:")) {
+									dataLines.push(line.replace(/^data:\s*/, ""));
+								} else if (line.startsWith("event:")) {
+									eventName = line.replace(/^event:\s*/, "");
+								} else if (line.startsWith("id:")) {
+									lastEventId = line.replace(/^id:\s*/, "");
+								} else if (line.startsWith("retry:")) {
+									const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+									if (!Number.isNaN(parsed)) {
+										retryDelay = parsed;
+									}
+								}
+							}
+
+							let data: unknown;
+							let parsedJson = false;
+
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+
+							if (parsedJson) {
+								if (responseValidator) {
+									await responseValidator(data);
+								}
+
+								if (responseTransformer) {
+									data = await responseTransformer(data);
+								}
+							}
+
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay,
+							});
+
+							if (dataLines.length) {
+								yield data as any;
+							}
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+
+				break; // exit loop on normal completion
+			} catch (error) {
+				// connection failed or aborted; retry after delay
+				onSseError?.(error);
+
+				if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) {
+					break; // stop after firing error
+				}
+
+				// exponential backoff: double retry each attempt, cap at 30s
+				const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 30000);
+				await sleep(backoff);
+			}
+		}
+	};
+
+	const stream = createStream();
+
+	return { stream };
+};
--- a/app/client/api-client/core/types.gen.ts
+++ b/app/client/api-client/core/types.gen.ts
@@ -0,0 +1,86 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Auth, AuthToken } from "./auth.gen";
+import type { BodySerializer, QuerySerializer, QuerySerializerOptions } from "./bodySerializer.gen";
+
+export type HttpMethod = "connect" | "delete" | "get" | "head" | "options" | "patch" | "post" | "put" | "trace";
+
+export type Client<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+	/**
+	 * Returns the final request URL.
+	 */
+	buildUrl: BuildUrlFn;
+	getConfig: () => Config;
+	request: RequestFn;
+	setConfig: (config: Config) => Config;
+} & {
+	[K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? { sse?: never } : { sse: { [K in HttpMethod]: SseFn } });
+
+export interface Config {
+	/**
+	 * Auth token or a function returning auth token. The resolved value will be
+	 * added to the request payload as defined by its `security` array.
+	 */
+	auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+	/**
+	 * A function for serializing request body parameter. By default,
+	 * {@link JSON.stringify()} will be used.
+	 */
+	bodySerializer?: BodySerializer | null;
+	/**
+	 * An object containing any HTTP headers that you want to pre-populate your
+	 * `Headers` object with.
+	 *
+	 * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+	 */
+	headers?:
+		| RequestInit["headers"]
+		| Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+	/**
+	 * The request method.
+	 *
+	 * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+	 */
+	method?: Uppercase<HttpMethod>;
+	/**
+	 * A function for serializing request query parameters. By default, arrays
+	 * will be exploded in form style, objects will be exploded in deepObject
+	 * style, and reserved characters are percent-encoded.
+	 *
+	 * This method will have no effect if the native `paramsSerializer()` Axios
+	 * API function is used.
+	 *
+	 * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+	 */
+	querySerializer?: QuerySerializer | QuerySerializerOptions;
+	/**
+	 * A function validating request data. This is useful if you want to ensure
+	 * the request conforms to the desired shape, so it can be safely sent to
+	 * the server.
+	 */
+	requestValidator?: (data: unknown) => Promise<unknown>;
+	/**
+	 * A function transforming response data before it's returned. This is useful
+	 * for post-processing data, e.g. converting ISO strings into Date objects.
+	 */
+	responseTransformer?: (data: unknown) => Promise<unknown>;
+	/**
+	 * A function validating response data. This is useful if you want to ensure
+	 * the response conforms to the desired shape, so it can be safely passed to
+	 * the transformers and returned to the user.
+	 */
+	responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never]
+	? true
+	: [T] extends [never | undefined]
+		? [undefined] extends [T]
+			? false
+			: true
+		: false;
+
+export type OmitNever<T extends Record<string, unknown>> = {
+	[K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true ? never : K]: T[K];
+};
--- a/app/client/api-client/core/utils.gen.ts
+++ b/app/client/api-client/core/utils.gen.ts
@@ -0,0 +1,137 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { BodySerializer, QuerySerializer } from "./bodySerializer.gen";
+import {
+	type ArraySeparatorStyle,
+	serializeArrayParam,
+	serializeObjectParam,
+	serializePrimitiveParam,
+} from "./pathSerializer.gen";
+
+export interface PathSerializer {
+	path: Record<string, unknown>;
+	url: string;
+}
+
+export const PATH_PARAM_RE = /\{[^{}]+\}/g;
+
+export const defaultPathSerializer = ({ path, url: _url }: PathSerializer) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) {
+		for (const match of matches) {
+			let explode = false;
+			let name = match.substring(1, match.length - 1);
+			let style: ArraySeparatorStyle = "simple";
+
+			if (name.endsWith("*")) {
+				explode = true;
+				name = name.substring(0, name.length - 1);
+			}
+
+			if (name.startsWith(".")) {
+				name = name.substring(1);
+				style = "label";
+			} else if (name.startsWith(";")) {
+				name = name.substring(1);
+				style = "matrix";
+			}
+
+			const value = path[name];
+
+			if (value === undefined || value === null) {
+				continue;
+			}
+
+			if (Array.isArray(value)) {
+				url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
+				continue;
+			}
+
+			if (typeof value === "object") {
+				url = url.replace(
+					match,
+					serializeObjectParam({
+						explode,
+						name,
+						style,
+						value: value as Record<string, unknown>,
+						valueOnly: true,
+					}),
+				);
+				continue;
+			}
+
+			if (style === "matrix") {
+				url = url.replace(
+					match,
+					`;${serializePrimitiveParam({
+						name,
+						value: value as string,
+					})}`,
+				);
+				continue;
+			}
+
+			const replaceValue = encodeURIComponent(style === "label" ? `.${value as string}` : (value as string));
+			url = url.replace(match, replaceValue);
+		}
+	}
+	return url;
+};
+
+export const getUrl = ({
+	baseUrl,
+	path,
+	query,
+	querySerializer,
+	url: _url,
+}: {
+	baseUrl?: string;
+	path?: Record<string, unknown>;
+	query?: Record<string, unknown>;
+	querySerializer: QuerySerializer;
+	url: string;
+}) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) {
+		url = defaultPathSerializer({ path, url });
+	}
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) {
+		search = search.substring(1);
+	}
+	if (search) {
+		url += `?${search}`;
+	}
+	return url;
+};
+
+export function getValidRequestBody(options: {
+	body?: unknown;
+	bodySerializer?: BodySerializer | null;
+	serializedBody?: unknown;
+}) {
+	const hasBody = options.body !== undefined;
+	const isSerializedBody = hasBody && options.bodySerializer;
+
+	if (isSerializedBody) {
+		if ("serializedBody" in options) {
+			const hasSerializedBody = options.serializedBody !== undefined && options.serializedBody !== "";
+
+			return hasSerializedBody ? options.serializedBody : null;
+		}
+
+		// not all clients implement a serializedBody property (i.e. client-axios)
+		return options.body !== "" ? options.body : null;
+	}
+
+	// plain/text body
+	if (hasBody) {
+		return options.body;
+	}
+
+	// no body was provided
+	return undefined;
+}
--- a/app/client/api-client/index.ts
+++ b/app/client/api-client/index.ts
@@ -0,0 +1,4 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type * from "./types.gen";
+export * from "./sdk.gen";
--- a/app/client/api-client/sdk.gen.ts
+++ b/app/client/api-client/sdk.gen.ts
@@ -0,0 +1,588 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Client, Options as Options2, TDataShape } from "./client";
+import { client } from "./client.gen";
+import type {
+	BrowseFilesystemData,
+	BrowseFilesystemResponses,
+	ChangePasswordData,
+	ChangePasswordResponses,
+	CreateBackupScheduleData,
+	CreateBackupScheduleResponses,
+	CreateRepositoryData,
+	CreateRepositoryResponses,
+	CreateVolumeData,
+	CreateVolumeResponses,
+	DeleteBackupScheduleData,
+	DeleteBackupScheduleResponses,
+	DeleteRepositoryData,
+	DeleteRepositoryResponses,
+	DeleteVolumeData,
+	DeleteVolumeResponses,
+	DoctorRepositoryData,
+	DoctorRepositoryResponses,
+	DownloadResticPasswordData,
+	DownloadResticPasswordResponses,
+	GetBackupScheduleData,
+	GetBackupScheduleForVolumeData,
+	GetBackupScheduleForVolumeResponses,
+	GetBackupScheduleResponses,
+	GetContainersUsingVolumeData,
+	GetContainersUsingVolumeErrors,
+	GetContainersUsingVolumeResponses,
+	GetMeData,
+	GetMeResponses,
+	GetRepositoryData,
+	GetRepositoryResponses,
+	GetSnapshotDetailsData,
+	GetSnapshotDetailsResponses,
+	GetStatusData,
+	GetStatusResponses,
+	GetSystemInfoData,
+	GetSystemInfoResponses,
+	GetVolumeData,
+	GetVolumeErrors,
+	GetVolumeResponses,
+	HealthCheckVolumeData,
+	HealthCheckVolumeErrors,
+	HealthCheckVolumeResponses,
+	ListBackupSchedulesData,
+	ListBackupSchedulesResponses,
+	ListFilesData,
+	ListFilesResponses,
+	ListRcloneRemotesData,
+	ListRcloneRemotesResponses,
+	ListRepositoriesData,
+	ListRepositoriesResponses,
+	ListSnapshotFilesData,
+	ListSnapshotFilesResponses,
+	ListSnapshotsData,
+	ListSnapshotsResponses,
+	ListVolumesData,
+	ListVolumesResponses,
+	LoginData,
+	LoginResponses,
+	LogoutData,
+	LogoutResponses,
+	MountVolumeData,
+	MountVolumeResponses,
+	RegisterData,
+	RegisterResponses,
+	RestoreSnapshotData,
+	RestoreSnapshotResponses,
+	RunBackupNowData,
+	RunBackupNowResponses,
+	StopBackupData,
+	StopBackupErrors,
+	StopBackupResponses,
+	TestConnectionData,
+	TestConnectionResponses,
+	UnmountVolumeData,
+	UnmountVolumeResponses,
+	UpdateBackupScheduleData,
+	UpdateBackupScheduleResponses,
+	UpdateVolumeData,
+	UpdateVolumeErrors,
+	UpdateVolumeResponses,
+} from "./types.gen";
+
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options2<
+	TData,
+	ThrowOnError
+> & {
+	/**
+	 * You can provide a client instance returned by `createClient()` instead of
+	 * individual options. This might be also useful if you want to implement a
+	 * custom client.
+	 */
+	client?: Client;
+	/**
+	 * You can pass arbitrary values through the `meta` object. This can be
+	 * used to access values that aren't defined as part of the SDK function.
+	 */
+	meta?: Record<string, unknown>;
+};
+
+/**
+ * Register a new user
+ */
+export const register = <ThrowOnError extends boolean = false>(options?: Options<RegisterData, ThrowOnError>) => {
+	return (options?.client ?? client).post<RegisterResponses, unknown, ThrowOnError>({
+		url: "/api/v1/auth/register",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers,
+		},
+	});
+};
+
+/**
+ * Login with username and password
+ */
+export const login = <ThrowOnError extends boolean = false>(options?: Options<LoginData, ThrowOnError>) => {
+	return (options?.client ?? client).post<LoginResponses, unknown, ThrowOnError>({
+		url: "/api/v1/auth/login",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers,
+		},
+	});
+};
+
+/**
+ * Logout current user
+ */
+export const logout = <ThrowOnError extends boolean = false>(options?: Options<LogoutData, ThrowOnError>) => {
+	return (options?.client ?? client).post<LogoutResponses, unknown, ThrowOnError>({
+		url: "/api/v1/auth/logout",
+		...options,
+	});
+};
+
+/**
+ * Get current authenticated user
+ */
+export const getMe = <ThrowOnError extends boolean = false>(options?: Options<GetMeData, ThrowOnError>) => {
+	return (options?.client ?? client).get<GetMeResponses, unknown, ThrowOnError>({
+		url: "/api/v1/auth/me",
+		...options,
+	});
+};
+
+/**
+ * Get authentication system status
+ */
+export const getStatus = <ThrowOnError extends boolean = false>(options?: Options<GetStatusData, ThrowOnError>) => {
+	return (options?.client ?? client).get<GetStatusResponses, unknown, ThrowOnError>({
+		url: "/api/v1/auth/status",
+		...options,
+	});
+};
+
+/**
+ * Change current user password
+ */
+export const changePassword = <ThrowOnError extends boolean = false>(
+	options?: Options<ChangePasswordData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).post<ChangePasswordResponses, unknown, ThrowOnError>({
+		url: "/api/v1/auth/change-password",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers,
+		},
+	});
+};
+
+/**
+ * List all volumes
+ */
+export const listVolumes = <ThrowOnError extends boolean = false>(options?: Options<ListVolumesData, ThrowOnError>) => {
+	return (options?.client ?? client).get<ListVolumesResponses, unknown, ThrowOnError>({
+		url: "/api/v1/volumes",
+		...options,
+	});
+};
+
+/**
+ * Create a new volume
+ */
+export const createVolume = <ThrowOnError extends boolean = false>(
+	options?: Options<CreateVolumeData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).post<CreateVolumeResponses, unknown, ThrowOnError>({
+		url: "/api/v1/volumes",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers,
+		},
+	});
+};
+
+/**
+ * Test connection to backend
+ */
+export const testConnection = <ThrowOnError extends boolean = false>(
+	options?: Options<TestConnectionData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).post<TestConnectionResponses, unknown, ThrowOnError>({
+		url: "/api/v1/volumes/test-connection",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers,
+		},
+	});
+};
+
+/**
+ * Delete a volume
+ */
+export const deleteVolume = <ThrowOnError extends boolean = false>(
+	options: Options<DeleteVolumeData, ThrowOnError>,
+) => {
+	return (options.client ?? client).delete<DeleteVolumeResponses, unknown, ThrowOnError>({
+		url: "/api/v1/volumes/{name}",
+		...options,
+	});
+};
+
+/**
+ * Get a volume by name
+ */
+export const getVolume = <ThrowOnError extends boolean = false>(options: Options<GetVolumeData, ThrowOnError>) => {
+	return (options.client ?? client).get<GetVolumeResponses, GetVolumeErrors, ThrowOnError>({
+		url: "/api/v1/volumes/{name}",
+		...options,
+	});
+};
+
+/**
+ * Update a volume's configuration
+ */
+export const updateVolume = <ThrowOnError extends boolean = false>(
+	options: Options<UpdateVolumeData, ThrowOnError>,
+) => {
+	return (options.client ?? client).put<UpdateVolumeResponses, UpdateVolumeErrors, ThrowOnError>({
+		url: "/api/v1/volumes/{name}",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options.headers,
+		},
+	});
+};
+
+/**
+ * Get containers using a volume by name
+ */
+export const getContainersUsingVolume = <ThrowOnError extends boolean = false>(
+	options: Options<GetContainersUsingVolumeData, ThrowOnError>,
+) => {
+	return (options.client ?? client).get<
+		GetContainersUsingVolumeResponses,
+		GetContainersUsingVolumeErrors,
+		ThrowOnError
+	>({
+		url: "/api/v1/volumes/{name}/containers",
+		...options,
+	});
+};
+
+/**
+ * Mount a volume
+ */
+export const mountVolume = <ThrowOnError extends boolean = false>(options: Options<MountVolumeData, ThrowOnError>) => {
+	return (options.client ?? client).post<MountVolumeResponses, unknown, ThrowOnError>({
+		url: "/api/v1/volumes/{name}/mount",
+		...options,
+	});
+};
+
+/**
+ * Unmount a volume
+ */
+export const unmountVolume = <ThrowOnError extends boolean = false>(
+	options: Options<UnmountVolumeData, ThrowOnError>,
+) => {
+	return (options.client ?? client).post<UnmountVolumeResponses, unknown, ThrowOnError>({
+		url: "/api/v1/volumes/{name}/unmount",
+		...options,
+	});
+};
+
+/**
+ * Perform a health check on a volume
+ */
+export const healthCheckVolume = <ThrowOnError extends boolean = false>(
+	options: Options<HealthCheckVolumeData, ThrowOnError>,
+) => {
+	return (options.client ?? client).post<HealthCheckVolumeResponses, HealthCheckVolumeErrors, ThrowOnError>({
+		url: "/api/v1/volumes/{name}/health-check",
+		...options,
+	});
+};
+
+/**
+ * List files in a volume directory
+ */
+export const listFiles = <ThrowOnError extends boolean = false>(options: Options<ListFilesData, ThrowOnError>) => {
+	return (options.client ?? client).get<ListFilesResponses, unknown, ThrowOnError>({
+		url: "/api/v1/volumes/{name}/files",
+		...options,
+	});
+};
+
+/**
+ * Browse directories on the host filesystem
+ */
+export const browseFilesystem = <ThrowOnError extends boolean = false>(
+	options?: Options<BrowseFilesystemData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).get<BrowseFilesystemResponses, unknown, ThrowOnError>({
+		url: "/api/v1/volumes/filesystem/browse",
+		...options,
+	});
+};
+
+/**
+ * List all repositories
+ */
+export const listRepositories = <ThrowOnError extends boolean = false>(
+	options?: Options<ListRepositoriesData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).get<ListRepositoriesResponses, unknown, ThrowOnError>({
+		url: "/api/v1/repositories",
+		...options,
+	});
+};
+
+/**
+ * Create a new restic repository
+ */
+export const createRepository = <ThrowOnError extends boolean = false>(
+	options?: Options<CreateRepositoryData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).post<CreateRepositoryResponses, unknown, ThrowOnError>({
+		url: "/api/v1/repositories",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers,
+		},
+	});
+};
+
+/**
+ * List all configured rclone remotes on the host system
+ */
+export const listRcloneRemotes = <ThrowOnError extends boolean = false>(
+	options?: Options<ListRcloneRemotesData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).get<ListRcloneRemotesResponses, unknown, ThrowOnError>({
+		url: "/api/v1/repositories/rclone-remotes",
+		...options,
+	});
+};
+
+/**
+ * Delete a repository
+ */
+export const deleteRepository = <ThrowOnError extends boolean = false>(
+	options: Options<DeleteRepositoryData, ThrowOnError>,
+) => {
+	return (options.client ?? client).delete<DeleteRepositoryResponses, unknown, ThrowOnError>({
+		url: "/api/v1/repositories/{name}",
+		...options,
+	});
+};
+
+/**
+ * Get a single repository by name
+ */
+export const getRepository = <ThrowOnError extends boolean = false>(
+	options: Options<GetRepositoryData, ThrowOnError>,
+) => {
+	return (options.client ?? client).get<GetRepositoryResponses, unknown, ThrowOnError>({
+		url: "/api/v1/repositories/{name}",
+		...options,
+	});
+};
+
+/**
+ * List all snapshots in a repository
+ */
+export const listSnapshots = <ThrowOnError extends boolean = false>(
+	options: Options<ListSnapshotsData, ThrowOnError>,
+) => {
+	return (options.client ?? client).get<ListSnapshotsResponses, unknown, ThrowOnError>({
+		url: "/api/v1/repositories/{name}/snapshots",
+		...options,
+	});
+};
+
+/**
+ * Get details of a specific snapshot
+ */
+export const getSnapshotDetails = <ThrowOnError extends boolean = false>(
+	options: Options<GetSnapshotDetailsData, ThrowOnError>,
+) => {
+	return (options.client ?? client).get<GetSnapshotDetailsResponses, unknown, ThrowOnError>({
+		url: "/api/v1/repositories/{name}/snapshots/{snapshotId}",
+		...options,
+	});
+};
+
+/**
+ * List files and directories in a snapshot
+ */
+export const listSnapshotFiles = <ThrowOnError extends boolean = false>(
+	options: Options<ListSnapshotFilesData, ThrowOnError>,
+) => {
+	return (options.client ?? client).get<ListSnapshotFilesResponses, unknown, ThrowOnError>({
+		url: "/api/v1/repositories/{name}/snapshots/{snapshotId}/files",
+		...options,
+	});
+};
+
+/**
+ * Restore a snapshot to a target path on the filesystem
+ */
+export const restoreSnapshot = <ThrowOnError extends boolean = false>(
+	options: Options<RestoreSnapshotData, ThrowOnError>,
+) => {
+	return (options.client ?? client).post<RestoreSnapshotResponses, unknown, ThrowOnError>({
+		url: "/api/v1/repositories/{name}/restore",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options.headers,
+		},
+	});
+};
+
+/**
+ * Run doctor operations on a repository to fix common issues (unlock, check, repair index). Use this when the repository is locked or has errors.
+ */
+export const doctorRepository = <ThrowOnError extends boolean = false>(
+	options: Options<DoctorRepositoryData, ThrowOnError>,
+) => {
+	return (options.client ?? client).post<DoctorRepositoryResponses, unknown, ThrowOnError>({
+		url: "/api/v1/repositories/{name}/doctor",
+		...options,
+	});
+};
+
+/**
+ * List all backup schedules
+ */
+export const listBackupSchedules = <ThrowOnError extends boolean = false>(
+	options?: Options<ListBackupSchedulesData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).get<ListBackupSchedulesResponses, unknown, ThrowOnError>({
+		url: "/api/v1/backups",
+		...options,
+	});
+};
+
+/**
+ * Create a new backup schedule for a volume
+ */
+export const createBackupSchedule = <ThrowOnError extends boolean = false>(
+	options?: Options<CreateBackupScheduleData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).post<CreateBackupScheduleResponses, unknown, ThrowOnError>({
+		url: "/api/v1/backups",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers,
+		},
+	});
+};
+
+/**
+ * Delete a backup schedule
+ */
+export const deleteBackupSchedule = <ThrowOnError extends boolean = false>(
+	options: Options<DeleteBackupScheduleData, ThrowOnError>,
+) => {
+	return (options.client ?? client).delete<DeleteBackupScheduleResponses, unknown, ThrowOnError>({
+		url: "/api/v1/backups/{scheduleId}",
+		...options,
+	});
+};
+
+/**
+ * Get a backup schedule by ID
+ */
+export const getBackupSchedule = <ThrowOnError extends boolean = false>(
+	options: Options<GetBackupScheduleData, ThrowOnError>,
+) => {
+	return (options.client ?? client).get<GetBackupScheduleResponses, unknown, ThrowOnError>({
+		url: "/api/v1/backups/{scheduleId}",
+		...options,
+	});
+};
+
+/**
+ * Update a backup schedule
+ */
+export const updateBackupSchedule = <ThrowOnError extends boolean = false>(
+	options: Options<UpdateBackupScheduleData, ThrowOnError>,
+) => {
+	return (options.client ?? client).patch<UpdateBackupScheduleResponses, unknown, ThrowOnError>({
+		url: "/api/v1/backups/{scheduleId}",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options.headers,
+		},
+	});
+};
+
+/**
+ * Get a backup schedule for a specific volume
+ */
+export const getBackupScheduleForVolume = <ThrowOnError extends boolean = false>(
+	options: Options<GetBackupScheduleForVolumeData, ThrowOnError>,
+) => {
+	return (options.client ?? client).get<GetBackupScheduleForVolumeResponses, unknown, ThrowOnError>({
+		url: "/api/v1/backups/volume/{volumeId}",
+		...options,
+	});
+};
+
+/**
+ * Trigger a backup immediately for a schedule
+ */
+export const runBackupNow = <ThrowOnError extends boolean = false>(
+	options: Options<RunBackupNowData, ThrowOnError>,
+) => {
+	return (options.client ?? client).post<RunBackupNowResponses, unknown, ThrowOnError>({
+		url: "/api/v1/backups/{scheduleId}/run",
+		...options,
+	});
+};
+
+/**
+ * Stop a backup that is currently in progress
+ */
+export const stopBackup = <ThrowOnError extends boolean = false>(options: Options<StopBackupData, ThrowOnError>) => {
+	return (options.client ?? client).post<StopBackupResponses, StopBackupErrors, ThrowOnError>({
+		url: "/api/v1/backups/{scheduleId}/stop",
+		...options,
+	});
+};
+
+/**
+ * Get system information including available capabilities
+ */
+export const getSystemInfo = <ThrowOnError extends boolean = false>(
+	options?: Options<GetSystemInfoData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).get<GetSystemInfoResponses, unknown, ThrowOnError>({
+		url: "/api/v1/system/info",
+		...options,
+	});
+};
+
+/**
+ * Download the Restic password file for backup recovery. Requires password re-authentication.
+ */
+export const downloadResticPassword = <ThrowOnError extends boolean = false>(
+	options?: Options<DownloadResticPasswordData, ThrowOnError>,
+) => {
+	return (options?.client ?? client).post<DownloadResticPasswordResponses, unknown, ThrowOnError>({
+		url: "/api/v1/system/restic-password",
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers,
+		},
+	});
+};
--- a/app/client/api-client/types.gen.ts
+++ b/app/client/api-client/types.gen.ts