// This file is auto-generated by @hey-api/openapi-ts

import {
	type DefaultError,
	type InfiniteData,
	infiniteQueryOptions,
	queryOptions,
	type UseMutationOptions,
} from "@tanstack/react-query";

import { client } from "../client.gen";
import {
	browseFilesystem,
	cancelDoctor,
	createBackupSchedule,
	createNotificationDestination,
	createRepository,
	createVolume,
	deleteBackupSchedule,
	deleteNotificationDestination,
	deleteRepository,
	deleteSnapshot,
	deleteSnapshots,
	deleteVolume,
	downloadResticPassword,
	getBackupSchedule,
	getBackupScheduleForVolume,
	getMirrorCompatibility,
	getNotificationDestination,
	getRegistrationStatus,
	getRepository,
	getScheduleMirrors,
	getScheduleNotifications,
	getSnapshotDetails,
	getStatus,
	getSystemInfo,
	getUpdates,
	getUserDeletionImpact,
	getVolume,
	healthCheckVolume,
	listBackupSchedules,
	listFiles,
	listNotificationDestinations,
	listRcloneRemotes,
	listRepositories,
	listSnapshotFiles,
	listSnapshots,
	listVolumes,
	mountVolume,
	type Options,
	refreshSnapshots,
	reorderBackupSchedules,
	restoreSnapshot,
	runBackupNow,
	runForget,
	setRegistrationStatus,
	startDoctor,
	stopBackup,
	tagSnapshots,
	testConnection,
	testNotificationDestination,
	unmountVolume,
	updateBackupSchedule,
	updateNotificationDestination,
	updateRepository,
	updateScheduleMirrors,
	updateScheduleNotifications,
	updateVolume,
} from "../sdk.gen";
import type {
	BrowseFilesystemData,
	BrowseFilesystemResponse,
	CancelDoctorData,
	CancelDoctorResponse,
	CreateBackupScheduleData,
	CreateBackupScheduleResponse,
	CreateNotificationDestinationData,
	CreateNotificationDestinationResponse,
	CreateRepositoryData,
	CreateRepositoryResponse,
	CreateVolumeData,
	CreateVolumeResponse,
	DeleteBackupScheduleData,
	DeleteBackupScheduleResponse,
	DeleteNotificationDestinationData,
	DeleteNotificationDestinationResponse,
	DeleteRepositoryData,
	DeleteRepositoryResponse,
	DeleteSnapshotData,
	DeleteSnapshotResponse,
	DeleteSnapshotsData,
	DeleteSnapshotsResponse,
	DeleteVolumeData,
	DeleteVolumeResponse,
	DownloadResticPasswordData,
	DownloadResticPasswordResponse,
	GetBackupScheduleData,
	GetBackupScheduleForVolumeData,
	GetBackupScheduleForVolumeResponse,
	GetBackupScheduleResponse,
	GetMirrorCompatibilityData,
	GetMirrorCompatibilityResponse,
	GetNotificationDestinationData,
	GetNotificationDestinationResponse,
	GetRegistrationStatusData,
	GetRegistrationStatusResponse,
	GetRepositoryData,
	GetRepositoryResponse,
	GetScheduleMirrorsData,
	GetScheduleMirrorsResponse,
	GetScheduleNotificationsData,
	GetScheduleNotificationsResponse,
	GetSnapshotDetailsData,
	GetSnapshotDetailsResponse,
	GetStatusData,
	GetStatusResponse,
	GetSystemInfoData,
	GetSystemInfoResponse,
	GetUpdatesData,
	GetUpdatesResponse,
	GetUserDeletionImpactData,
	GetUserDeletionImpactResponse,
	GetVolumeData,
	GetVolumeResponse,
	HealthCheckVolumeData,
	HealthCheckVolumeResponse,
	ListBackupSchedulesData,
	ListBackupSchedulesResponse,
	ListFilesData,
	ListFilesResponse,
	ListNotificationDestinationsData,
	ListNotificationDestinationsResponse,
	ListRcloneRemotesData,
	ListRcloneRemotesResponse,
	ListRepositoriesData,
	ListRepositoriesResponse,
	ListSnapshotFilesData,
	ListSnapshotFilesResponse,
	ListSnapshotsData,
	ListSnapshotsResponse,
	ListVolumesData,
	ListVolumesResponse,
	MountVolumeData,
	MountVolumeResponse,
	RefreshSnapshotsData,
	RefreshSnapshotsResponse,
	ReorderBackupSchedulesData,
	ReorderBackupSchedulesResponse,
	RestoreSnapshotData,
	RestoreSnapshotResponse,
	RunBackupNowData,
	RunBackupNowResponse,
	RunForgetData,
	RunForgetResponse,
	SetRegistrationStatusData,
	SetRegistrationStatusResponse,
	StartDoctorData,
	StartDoctorResponse,
	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 getUserDeletionImpactQueryKey = (options: Options<GetUserDeletionImpactData>) =>
	createQueryKey("getUserDeletionImpact", options);

/**
 * Get impact of deleting a user
 */
export const getUserDeletionImpactOptions = (options: Options<GetUserDeletionImpactData>) =>
	queryOptions<
		GetUserDeletionImpactResponse,
		DefaultError,
		GetUserDeletionImpactResponse,
		ReturnType<typeof getUserDeletionImpactQueryKey>
	>({
		queryFn: async ({ queryKey, signal }) => {
			const { data } = await getUserDeletionImpact({
				...options,
				...queryKey[0],
				signal,
				throwOnError: true,
			});
			return data;
		},
		queryKey: getUserDeletionImpactQueryKey(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),
	});

const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], "body" | "headers" | "path" | "query">>(
	queryKey: QueryKey<Options>,
	page: K,
) => {
	const params = { ...queryKey[0] };
	if (page.body) {
		params.body = {
			...(queryKey[0].body as any),
			...(page.body as any),
		};
	}
	if (page.headers) {
		params.headers = {
			...queryKey[0].headers,
			...page.headers,
		};
	}
	if (page.path) {
		params.path = {
			...(queryKey[0].path as any),
			...(page.path as any),
		};
	}
	if (page.query) {
		params.query = {
			...(queryKey[0].query as any),
			...(page.query as any),
		};
	}
	return params as unknown as typeof page;
};

export const listFilesInfiniteQueryKey = (options: Options<ListFilesData>): QueryKey<Options<ListFilesData>> =>
	createQueryKey("listFiles", options, true);

/**
 * List files in a volume directory
 */
export const listFilesInfiniteOptions = (options: Options<ListFilesData>) =>
	infiniteQueryOptions<
		ListFilesResponse,
		DefaultError,
		InfiniteData<ListFilesResponse>,
		QueryKey<Options<ListFilesData>>,
		string | Pick<QueryKey<Options<ListFilesData>>[0], "body" | "headers" | "path" | "query">
	>(
		// @ts-ignore
		{
			queryFn: async ({ pageParam, queryKey, signal }) => {
				// @ts-ignore
				const page: Pick<QueryKey<Options<ListFilesData>>[0], "body" | "headers" | "path" | "query"> =
					typeof pageParam === "object"
						? pageParam
						: {
								query: {
									offset: pageParam,
								},
							};
				const params = createInfiniteParams(queryKey, page);
				const { data } = await listFiles({
					...options,
					...params,
					signal,
					throwOnError: true,
				});
				return data;
			},
			queryKey: listFilesInfiniteQueryKey(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),
	});

/**
 * Clear snapshot cache and force refresh from repository
 */
export const refreshSnapshotsMutation = (
	options?: Partial<Options<RefreshSnapshotsData>>,
): UseMutationOptions<RefreshSnapshotsResponse, DefaultError, Options<RefreshSnapshotsData>> => {
	const mutationOptions: UseMutationOptions<RefreshSnapshotsResponse, DefaultError, Options<RefreshSnapshotsData>> = {
		mutationFn: async (fnOptions) => {
			const { data } = await refreshSnapshots({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

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

export const listSnapshotFilesInfiniteQueryKey = (
	options: Options<ListSnapshotFilesData>,
): QueryKey<Options<ListSnapshotFilesData>> => createQueryKey("listSnapshotFiles", options, true);

/**
 * List files and directories in a snapshot
 */
export const listSnapshotFilesInfiniteOptions = (options: Options<ListSnapshotFilesData>) =>
	infiniteQueryOptions<
		ListSnapshotFilesResponse,
		DefaultError,
		InfiniteData<ListSnapshotFilesResponse>,
		QueryKey<Options<ListSnapshotFilesData>>,
		string | Pick<QueryKey<Options<ListSnapshotFilesData>>[0], "body" | "headers" | "path" | "query">
	>(
		// @ts-ignore
		{
			queryFn: async ({ pageParam, queryKey, signal }) => {
				// @ts-ignore
				const page: Pick<QueryKey<Options<ListSnapshotFilesData>>[0], "body" | "headers" | "path" | "query"> =
					typeof pageParam === "object"
						? pageParam
						: {
								query: {
									offset: pageParam,
								},
							};
				const params = createInfiniteParams(queryKey, page);
				const { data } = await listSnapshotFiles({
					...options,
					...params,
					signal,
					throwOnError: true,
				});
				return data;
			},
			queryKey: listSnapshotFilesInfiniteQueryKey(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;
};

/**
 * Cancel a running doctor operation on a repository
 */
export const cancelDoctorMutation = (
	options?: Partial<Options<CancelDoctorData>>,
): UseMutationOptions<CancelDoctorResponse, DefaultError, Options<CancelDoctorData>> => {
	const mutationOptions: UseMutationOptions<CancelDoctorResponse, DefaultError, Options<CancelDoctorData>> = {
		mutationFn: async (fnOptions) => {
			const { data } = await cancelDoctor({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

/**
 * Start an asynchronous doctor operation on a repository to fix common issues (unlock, check, repair index). The operation runs in the background and sends results via SSE events.
 */
export const startDoctorMutation = (
	options?: Partial<Options<StartDoctorData>>,
): UseMutationOptions<StartDoctorResponse, DefaultError, Options<StartDoctorData>> => {
	const mutationOptions: UseMutationOptions<StartDoctorResponse, DefaultError, Options<StartDoctorData>> = {
		mutationFn: async (fnOptions) => {
			const { data } = await startDoctor({
				...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),
	});

export const getRegistrationStatusQueryKey = (options?: Options<GetRegistrationStatusData>) =>
	createQueryKey("getRegistrationStatus", options);

/**
 * Get the current registration status for new users
 */
export const getRegistrationStatusOptions = (options?: Options<GetRegistrationStatusData>) =>
	queryOptions<
		GetRegistrationStatusResponse,
		DefaultError,
		GetRegistrationStatusResponse,
		ReturnType<typeof getRegistrationStatusQueryKey>
	>({
		queryFn: async ({ queryKey, signal }) => {
			const { data } = await getRegistrationStatus({
				...options,
				...queryKey[0],
				signal,
				throwOnError: true,
			});
			return data;
		},
		queryKey: getRegistrationStatusQueryKey(options),
	});

/**
 * Update the registration status for new users. Requires global admin role.
 */
export const setRegistrationStatusMutation = (
	options?: Partial<Options<SetRegistrationStatusData>>,
): UseMutationOptions<SetRegistrationStatusResponse, DefaultError, Options<SetRegistrationStatusData>> => {
	const mutationOptions: UseMutationOptions<
		SetRegistrationStatusResponse,
		DefaultError,
		Options<SetRegistrationStatusData>
	> = {
		mutationFn: async (fnOptions) => {
			const { data } = await setRegistrationStatus({
				...options,
				...fnOptions,
				throwOnError: true,
			});
			return data;
		},
	};
	return mutationOptions;
};

/**
 * Download the organization's Restic password for backup recovery. Requires organization owner or admin role and 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;
};