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