zerobyte/app/client/api-client/@tanstack/react-query.gen.ts

// 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,
	createBackupSchedule,
	createNotificationDestination,
	createRepository,
	createVolume,
	deleteBackupSchedule,
	deleteNotificationDestination,
	deleteRepository,
	deleteSnapshot,
	deleteSnapshots,
	deleteVolume,
	doctorRepository,
	downloadResticPassword,
	getBackupSchedule,
	getBackupScheduleForVolume,
	getMirrorCompatibility,
	getNotificationDestination,
	getRepository,
	getScheduleMirrors,
	getScheduleNotifications,
	getSnapshotDetails,
	getStatus,
	getSystemInfo,
	getUpdates,
	getVolume,
	healthCheckVolume,
	listBackupSchedules,
	listFiles,
	listNotificationDestinations,
	listRcloneRemotes,
	listRepositories,
	listSnapshotFiles,
	listSnapshots,
	listVolumes,
	mountVolume,
	type Options,
	reorderBackupSchedules,
	restoreSnapshot,
	runBackupNow,
	runForget,
	stopBackup,
	tagSnapshots,
	testConnection,
	testNotificationDestination,
	unmountVolume,
	updateBackupSchedule,
	updateNotificationDestination,
	updateRepository,
	updateScheduleMirrors,
	updateScheduleNotifications,
	updateVolume,
} from "../sdk.gen";
import type {
	BrowseFilesystemData,
	BrowseFilesystemResponse,
	CreateBackupScheduleData,
	CreateBackupScheduleResponse,
	CreateNotificationDestinationData,
	CreateNotificationDestinationResponse,
	CreateRepositoryData,
	CreateRepositoryResponse,
	CreateVolumeData,
	CreateVolumeResponse,
	DeleteBackupScheduleData,
	DeleteBackupScheduleResponse,
	DeleteNotificationDestinationData,
	DeleteNotificationDestinationResponse,
	DeleteRepositoryData,
	DeleteRepositoryResponse,
	DeleteSnapshotData,
	DeleteSnapshotResponse,
	DeleteSnapshotsData,
	DeleteSnapshotsResponse,
	DeleteVolumeData,
	DeleteVolumeResponse,
	DoctorRepositoryData,
	DoctorRepositoryResponse,
	DownloadResticPasswordData,
	DownloadResticPasswordResponse,
	GetBackupScheduleData,
	GetBackupScheduleForVolumeData,
	GetBackupScheduleForVolumeResponse,
	GetBackupScheduleResponse,
	GetMirrorCompatibilityData,
	GetMirrorCompatibilityResponse,
	GetNotificationDestinationData,
	GetNotificationDestinationResponse,
	GetRepositoryData,
	GetRepositoryResponse,
	GetScheduleMirrorsData,
	GetScheduleMirrorsResponse,
	GetScheduleNotificationsData,
	GetScheduleNotificationsResponse,
	GetSnapshotDetailsData,
	GetSnapshotDetailsResponse,
	GetStatusData,
	GetStatusResponse,
	GetSystemInfoData,
	GetSystemInfoResponse,
	GetUpdatesData,
	GetUpdatesResponse,
	GetVolumeData,
	GetVolumeResponse,
	HealthCheckVolumeData,
	HealthCheckVolumeResponse,
	ListBackupSchedulesData,
	ListBackupSchedulesResponse,
	ListFilesData,
	ListFilesResponse,
	ListNotificationDestinationsData,
	ListNotificationDestinationsResponse,
	ListRcloneRemotesData,
	ListRcloneRemotesResponse,
	ListRepositoriesData,
	ListRepositoriesResponse,
	ListSnapshotFilesData,
	ListSnapshotFilesResponse,
	ListSnapshotsData,
	ListSnapshotsResponse,
	ListVolumesData,
	ListVolumesResponse,
	MountVolumeData,
	MountVolumeResponse,
	ReorderBackupSchedulesData,
	ReorderBackupSchedulesResponse,
	RestoreSnapshotData,
	RestoreSnapshotResponse,
	RunBackupNowData,
	RunBackupNowResponse,
	RunForgetData,
	RunForgetResponse,
	StopBackupData,
	StopBackupResponse,
	TagSnapshotsData,
	TagSnapshotsResponse,
	TestConnectionData,
	TestConnectionResponse,
	TestNotificationDestinationData,
	TestNotificationDestinationResponse,
	UnmountVolumeData,
	UnmountVolumeResponse,
	UpdateBackupScheduleData,
	UpdateBackupScheduleResponse,
	UpdateNotificationDestinationData,
	UpdateNotificationDestinationResponse,
	UpdateRepositoryData,
	UpdateRepositoryResponse,
	UpdateScheduleMirrorsData,
	UpdateScheduleMirrorsResponse,
	UpdateScheduleNotificationsData,
	UpdateScheduleNotificationsResponse,
	UpdateVolumeData,
	UpdateVolumeResponse,
} from "../types.gen";

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 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),
	});

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;
};

/**
 * 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 ID
 */
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),
	});

/**
 * Update a repository's name or settings
 */
export const updateRepositoryMutation = (
	options?: Partial<Options<UpdateRepositoryData>>,
): UseMutationOptions<
	UpdateRepositoryResponse,
	DefaultError,
	Options<UpdateRepositoryData>
> => {
	const mutationOptions: UseMutationOptions<
		UpdateRepositoryResponse,
		DefaultError,
		Options<UpdateRepositoryData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await updateRepository({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

/**
 * Delete multiple snapshots from a repository
 */
export const deleteSnapshotsMutation = (
	options?: Partial<Options<DeleteSnapshotsData>>,
): UseMutationOptions<
	DeleteSnapshotsResponse,
	DefaultError,
	Options<DeleteSnapshotsData>
> => {
	const mutationOptions: UseMutationOptions<
		DeleteSnapshotsResponse,
		DefaultError,
		Options<DeleteSnapshotsData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await deleteSnapshots({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

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),
	});

/**
 * Delete a specific snapshot from a repository
 */
export const deleteSnapshotMutation = (
	options?: Partial<Options<DeleteSnapshotData>>,
): UseMutationOptions<
	DeleteSnapshotResponse,
	DefaultError,
	Options<DeleteSnapshotData>
> => {
	const mutationOptions: UseMutationOptions<
		DeleteSnapshotResponse,
		DefaultError,
		Options<DeleteSnapshotData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await deleteSnapshot({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

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;
};

/**
 * Tag multiple snapshots in a repository
 */
export const tagSnapshotsMutation = (
	options?: Partial<Options<TagSnapshotsData>>,
): UseMutationOptions<
	TagSnapshotsResponse,
	DefaultError,
	Options<TagSnapshotsData>
> => {
	const mutationOptions: UseMutationOptions<
		TagSnapshotsResponse,
		DefaultError,
		Options<TagSnapshotsData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await tagSnapshots({
				...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;
};

/**
 * Manually apply retention policy to clean up old snapshots
 */
export const runForgetMutation = (
	options?: Partial<Options<RunForgetData>>,
): UseMutationOptions<
	RunForgetResponse,
	DefaultError,
	Options<RunForgetData>
> => {
	const mutationOptions: UseMutationOptions<
		RunForgetResponse,
		DefaultError,
		Options<RunForgetData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await runForget({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

export const getScheduleNotificationsQueryKey = (
	options: Options<GetScheduleNotificationsData>,
) => createQueryKey("getScheduleNotifications", options);

/**
 * Get notification assignments for a backup schedule
 */
export const getScheduleNotificationsOptions = (
	options: Options<GetScheduleNotificationsData>,
) =>
	queryOptions<
		GetScheduleNotificationsResponse,
		DefaultError,
		GetScheduleNotificationsResponse,
		ReturnType<typeof getScheduleNotificationsQueryKey>
	>({
		queryFn: async ({ queryKey, signal }) => {
			const { data } = await getScheduleNotifications({
				...options,
				...queryKey[0],
				signal,
				throwOnError: true,
			});
			return data;
		},
		queryKey: getScheduleNotificationsQueryKey(options),
	});

/**
 * Update notification assignments for a backup schedule
 */
export const updateScheduleNotificationsMutation = (
	options?: Partial<Options<UpdateScheduleNotificationsData>>,
): UseMutationOptions<
	UpdateScheduleNotificationsResponse,
	DefaultError,
	Options<UpdateScheduleNotificationsData>
> => {
	const mutationOptions: UseMutationOptions<
		UpdateScheduleNotificationsResponse,
		DefaultError,
		Options<UpdateScheduleNotificationsData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await updateScheduleNotifications({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

export const getScheduleMirrorsQueryKey = (
	options: Options<GetScheduleMirrorsData>,
) => createQueryKey("getScheduleMirrors", options);

/**
 * Get mirror repository assignments for a backup schedule
 */
export const getScheduleMirrorsOptions = (
	options: Options<GetScheduleMirrorsData>,
) =>
	queryOptions<
		GetScheduleMirrorsResponse,
		DefaultError,
		GetScheduleMirrorsResponse,
		ReturnType<typeof getScheduleMirrorsQueryKey>
	>({
		queryFn: async ({ queryKey, signal }) => {
			const { data } = await getScheduleMirrors({
				...options,
				...queryKey[0],
				signal,
				throwOnError: true,
			});
			return data;
		},
		queryKey: getScheduleMirrorsQueryKey(options),
	});

/**
 * Update mirror repository assignments for a backup schedule
 */
export const updateScheduleMirrorsMutation = (
	options?: Partial<Options<UpdateScheduleMirrorsData>>,
): UseMutationOptions<
	UpdateScheduleMirrorsResponse,
	DefaultError,
	Options<UpdateScheduleMirrorsData>
> => {
	const mutationOptions: UseMutationOptions<
		UpdateScheduleMirrorsResponse,
		DefaultError,
		Options<UpdateScheduleMirrorsData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await updateScheduleMirrors({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

export const getMirrorCompatibilityQueryKey = (
	options: Options<GetMirrorCompatibilityData>,
) => createQueryKey("getMirrorCompatibility", options);

/**
 * Get mirror compatibility info for all repositories relative to a backup schedule's primary repository
 */
export const getMirrorCompatibilityOptions = (
	options: Options<GetMirrorCompatibilityData>,
) =>
	queryOptions<
		GetMirrorCompatibilityResponse,
		DefaultError,
		GetMirrorCompatibilityResponse,
		ReturnType<typeof getMirrorCompatibilityQueryKey>
	>({
		queryFn: async ({ queryKey, signal }) => {
			const { data } = await getMirrorCompatibility({
				...options,
				...queryKey[0],
				signal,
				throwOnError: true,
			});
			return data;
		},
		queryKey: getMirrorCompatibilityQueryKey(options),
	});

/**
 * Reorder backup schedules by providing an array of schedule IDs in the desired order
 */
export const reorderBackupSchedulesMutation = (
	options?: Partial<Options<ReorderBackupSchedulesData>>,
): UseMutationOptions<
	ReorderBackupSchedulesResponse,
	DefaultError,
	Options<ReorderBackupSchedulesData>
> => {
	const mutationOptions: UseMutationOptions<
		ReorderBackupSchedulesResponse,
		DefaultError,
		Options<ReorderBackupSchedulesData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await reorderBackupSchedules({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

export const listNotificationDestinationsQueryKey = (
	options?: Options<ListNotificationDestinationsData>,
) => createQueryKey("listNotificationDestinations", options);

/**
 * List all notification destinations
 */
export const listNotificationDestinationsOptions = (
	options?: Options<ListNotificationDestinationsData>,
) =>
	queryOptions<
		ListNotificationDestinationsResponse,
		DefaultError,
		ListNotificationDestinationsResponse,
		ReturnType<typeof listNotificationDestinationsQueryKey>
	>({
		queryFn: async ({ queryKey, signal }) => {
			const { data } = await listNotificationDestinations({
				...options,
				...queryKey[0],
				signal,
				throwOnError: true,
			});
			return data;
		},
		queryKey: listNotificationDestinationsQueryKey(options),
	});

/**
 * Create a new notification destination
 */
export const createNotificationDestinationMutation = (
	options?: Partial<Options<CreateNotificationDestinationData>>,
): UseMutationOptions<
	CreateNotificationDestinationResponse,
	DefaultError,
	Options<CreateNotificationDestinationData>
> => {
	const mutationOptions: UseMutationOptions<
		CreateNotificationDestinationResponse,
		DefaultError,
		Options<CreateNotificationDestinationData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await createNotificationDestination({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

/**
 * Delete a notification destination
 */
export const deleteNotificationDestinationMutation = (
	options?: Partial<Options<DeleteNotificationDestinationData>>,
): UseMutationOptions<
	DeleteNotificationDestinationResponse,
	DefaultError,
	Options<DeleteNotificationDestinationData>
> => {
	const mutationOptions: UseMutationOptions<
		DeleteNotificationDestinationResponse,
		DefaultError,
		Options<DeleteNotificationDestinationData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await deleteNotificationDestination({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

export const getNotificationDestinationQueryKey = (
	options: Options<GetNotificationDestinationData>,
) => createQueryKey("getNotificationDestination", options);

/**
 * Get a notification destination by ID
 */
export const getNotificationDestinationOptions = (
	options: Options<GetNotificationDestinationData>,
) =>
	queryOptions<
		GetNotificationDestinationResponse,
		DefaultError,
		GetNotificationDestinationResponse,
		ReturnType<typeof getNotificationDestinationQueryKey>
	>({
		queryFn: async ({ queryKey, signal }) => {
			const { data } = await getNotificationDestination({
				...options,
				...queryKey[0],
				signal,
				throwOnError: true,
			});
			return data;
		},
		queryKey: getNotificationDestinationQueryKey(options),
	});

/**
 * Update a notification destination
 */
export const updateNotificationDestinationMutation = (
	options?: Partial<Options<UpdateNotificationDestinationData>>,
): UseMutationOptions<
	UpdateNotificationDestinationResponse,
	DefaultError,
	Options<UpdateNotificationDestinationData>
> => {
	const mutationOptions: UseMutationOptions<
		UpdateNotificationDestinationResponse,
		DefaultError,
		Options<UpdateNotificationDestinationData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await updateNotificationDestination({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

/**
 * Test a notification destination by sending a test message
 */
export const testNotificationDestinationMutation = (
	options?: Partial<Options<TestNotificationDestinationData>>,
): UseMutationOptions<
	TestNotificationDestinationResponse,
	DefaultError,
	Options<TestNotificationDestinationData>
> => {
	const mutationOptions: UseMutationOptions<
		TestNotificationDestinationResponse,
		DefaultError,
		Options<TestNotificationDestinationData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await testNotificationDestination({
				...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),
	});

export const getUpdatesQueryKey = (options?: Options<GetUpdatesData>) =>
	createQueryKey("getUpdates", options);

/**
 * Check for application updates from GitHub
 */
export const getUpdatesOptions = (options?: Options<GetUpdatesData>) =>
	queryOptions<
		GetUpdatesResponse,
		DefaultError,
		GetUpdatesResponse,
		ReturnType<typeof getUpdatesQueryKey>
	>({
		queryFn: async ({ queryKey, signal }) => {
			const { data } = await getUpdates({
				...options,
				...queryKey[0],
				signal,
				throwOnError: true,
			});
			return data;
		},
		queryKey: getUpdatesQueryKey(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;
};