authula 0.5.4 → 0.7.0

package/dist/plugins/index.js

@@ -1,154 +1,2399 @@
-import { r as sessionSchema, t as wrappedFetch } from "../fetch-BnZpQ0Yq.js";
-import { z } from "zod";
-import { parseCookie } from "cookie";
+import { t as __exportAll } from "../rolldown-runtime-w6R9maHv.js";
+import { n as customFetch } from "../custom-fetch-Ce6_l1Qb.js";
+import { useMutation, useQuery } from "@tanstack/react-query";
 
+//#region src/utils/wrap-generated.ts
+function isHookKey(key) {
+	return key.startsWith("use") && key[3] === key[3]?.toUpperCase();
+}
+function wrapGenerated(mod, client) {
+	const baseUrl = client.config.url.replace(/\/+$/, "");
+	const cookies = client.config.cookies;
+	const onBeforeFetch = (ctx) => client.runBeforeFetch(ctx);
+	const onAfterFetch = (ctx, res) => client.runAfterFetch(ctx, res);
+	const wrapped = {};
+	for (const [key, value] of Object.entries(mod)) {
+		if (typeof value !== "function") {
+			wrapped[key] = value;
+			continue;
+		}
+		if (isHookKey(key)) wrapped[key] = (options, ...rest) => value({
+			...options,
+			request: {
+				...options?.request,
+				baseUrl,
+				cookies,
+				onBeforeFetch,
+				onAfterFetch
+			}
+		}, ...rest);
+		else wrapped[key] = (...args) => {
+			const ctx = {
+				baseUrl,
+				cookies,
+				onBeforeFetch,
+				onAfterFetch
+			};
+			const optionsIdx = value.length - 1;
+			while (args.length < optionsIdx) args.push(void 0);
+			if (optionsIdx >= 0 && args.length === optionsIdx) args.push(ctx);
+			else if (optionsIdx >= 0) args[optionsIdx] = {
+				...args[optionsIdx],
+				...ctx
+			};
+			return value(...args);
+		};
+	}
+	return wrapped;
+}
+
+//#endregion
+//#region src/gen/endpoints/access-control/access-control.ts
+var access_control_exports = /* @__PURE__ */ __exportAll({
+	addRolePermission: () => addRolePermission,
+	assignUserRole: () => assignUserRole,
+	checkUserPermissions: () => checkUserPermissions,
+	createPermission: () => createPermission,
+	createRole: () => createRole,
+	deletePermission: () => deletePermission,
+	deleteRole: () => deleteRole,
+	getAddRolePermissionMutationOptions: () => getAddRolePermissionMutationOptions,
+	getAddRolePermissionUrl: () => getAddRolePermissionUrl,
+	getAssignUserRoleMutationOptions: () => getAssignUserRoleMutationOptions,
+	getAssignUserRoleUrl: () => getAssignUserRoleUrl,
+	getCheckUserPermissionsMutationOptions: () => getCheckUserPermissionsMutationOptions,
+	getCheckUserPermissionsUrl: () => getCheckUserPermissionsUrl,
+	getCreatePermissionMutationOptions: () => getCreatePermissionMutationOptions,
+	getCreatePermissionUrl: () => getCreatePermissionUrl,
+	getCreateRoleMutationOptions: () => getCreateRoleMutationOptions,
+	getCreateRoleUrl: () => getCreateRoleUrl,
+	getDeletePermissionMutationOptions: () => getDeletePermissionMutationOptions,
+	getDeletePermissionUrl: () => getDeletePermissionUrl,
+	getDeleteRoleMutationOptions: () => getDeleteRoleMutationOptions,
+	getDeleteRoleUrl: () => getDeleteRoleUrl,
+	getGetPermissionQueryKey: () => getGetPermissionQueryKey,
+	getGetPermissionQueryOptions: () => getGetPermissionQueryOptions,
+	getGetPermissionUrl: () => getGetPermissionUrl,
+	getGetRoleByNameQueryKey: () => getGetRoleByNameQueryKey,
+	getGetRoleByNameQueryOptions: () => getGetRoleByNameQueryOptions,
+	getGetRoleByNameUrl: () => getGetRoleByNameUrl,
+	getGetRoleQueryKey: () => getGetRoleQueryKey,
+	getGetRoleQueryOptions: () => getGetRoleQueryOptions,
+	getGetRoleUrl: () => getGetRoleUrl,
+	getGetUserPermissionsQueryKey: () => getGetUserPermissionsQueryKey,
+	getGetUserPermissionsQueryOptions: () => getGetUserPermissionsQueryOptions,
+	getGetUserPermissionsUrl: () => getGetUserPermissionsUrl,
+	getListPermissionsQueryKey: () => getListPermissionsQueryKey,
+	getListPermissionsQueryOptions: () => getListPermissionsQueryOptions,
+	getListPermissionsUrl: () => getListPermissionsUrl,
+	getListRolePermissionsQueryKey: () => getListRolePermissionsQueryKey,
+	getListRolePermissionsQueryOptions: () => getListRolePermissionsQueryOptions,
+	getListRolePermissionsUrl: () => getListRolePermissionsUrl,
+	getListRolesQueryKey: () => getListRolesQueryKey,
+	getListRolesQueryOptions: () => getListRolesQueryOptions,
+	getListRolesUrl: () => getListRolesUrl,
+	getListUserRolesQueryKey: () => getListUserRolesQueryKey,
+	getListUserRolesQueryOptions: () => getListUserRolesQueryOptions,
+	getListUserRolesUrl: () => getListUserRolesUrl,
+	getPermission: () => getPermission,
+	getRemoveRolePermissionMutationOptions: () => getRemoveRolePermissionMutationOptions,
+	getRemoveRolePermissionUrl: () => getRemoveRolePermissionUrl,
+	getRemoveUserRoleMutationOptions: () => getRemoveUserRoleMutationOptions,
+	getRemoveUserRoleUrl: () => getRemoveUserRoleUrl,
+	getReplaceRolePermissionsMutationOptions: () => getReplaceRolePermissionsMutationOptions,
+	getReplaceRolePermissionsUrl: () => getReplaceRolePermissionsUrl,
+	getReplaceUserRolesMutationOptions: () => getReplaceUserRolesMutationOptions,
+	getReplaceUserRolesUrl: () => getReplaceUserRolesUrl,
+	getRole: () => getRole,
+	getRoleByName: () => getRoleByName,
+	getUpdatePermissionMutationOptions: () => getUpdatePermissionMutationOptions,
+	getUpdatePermissionUrl: () => getUpdatePermissionUrl,
+	getUpdateRoleMutationOptions: () => getUpdateRoleMutationOptions,
+	getUpdateRoleUrl: () => getUpdateRoleUrl,
+	getUserPermissions: () => getUserPermissions,
+	listPermissions: () => listPermissions,
+	listRolePermissions: () => listRolePermissions,
+	listRoles: () => listRoles,
+	listUserRoles: () => listUserRoles,
+	removeRolePermission: () => removeRolePermission,
+	removeUserRole: () => removeUserRole,
+	replaceRolePermissions: () => replaceRolePermissions,
+	replaceUserRoles: () => replaceUserRoles,
+	updatePermission: () => updatePermission,
+	updateRole: () => updateRole,
+	useAddRolePermission: () => useAddRolePermission,
+	useAssignUserRole: () => useAssignUserRole,
+	useCheckUserPermissions: () => useCheckUserPermissions,
+	useCreatePermission: () => useCreatePermission,
+	useCreateRole: () => useCreateRole,
+	useDeletePermission: () => useDeletePermission,
+	useDeleteRole: () => useDeleteRole,
+	useGetPermission: () => useGetPermission,
+	useGetRole: () => useGetRole,
+	useGetRoleByName: () => useGetRoleByName,
+	useGetUserPermissions: () => useGetUserPermissions,
+	useListPermissions: () => useListPermissions,
+	useListRolePermissions: () => useListRolePermissions,
+	useListRoles: () => useListRoles,
+	useListUserRoles: () => useListUserRoles,
+	useRemoveRolePermission: () => useRemoveRolePermission,
+	useRemoveUserRole: () => useRemoveUserRole,
+	useReplaceRolePermissions: () => useReplaceRolePermissions,
+	useReplaceUserRoles: () => useReplaceUserRoles,
+	useUpdatePermission: () => useUpdatePermission,
+	useUpdateRole: () => useUpdateRole
+});
+const withQueryKey$13 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getListPermissionsUrl = () => {
+	return `/access-control/permissions`;
+};
+/**
+* Lists all permissions.
+* @summary List permissions
+*/
+const listPermissions = async (options) => {
+	return customFetch(getListPermissionsUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getListPermissionsQueryKey = () => {
+	return [`/access-control/permissions`];
+};
+const getListPermissionsQueryOptions = (options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListPermissionsQueryKey();
+	const queryFn = ({ signal }) => listPermissions({
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List permissions
+*/
+function useListPermissions(options, queryClient) {
+	const queryOptions = getListPermissionsQueryOptions(options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$13(query, queryOptions.queryKey);
+}
+const getCreatePermissionUrl = () => {
+	return `/access-control/permissions`;
+};
+/**
+* Creates a new permission.
+* @summary Create permission
+*/
+const createPermission = async (createPermissionRequest, options) => {
+	return customFetch(getCreatePermissionUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createPermissionRequest)
+	});
+};
+const getCreatePermissionMutationOptions = (options) => {
+	const mutationKey = ["createPermission"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return createPermission(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Create permission
+*/
+const useCreatePermission = (options, queryClient) => {
+	return useMutation(getCreatePermissionMutationOptions(options), queryClient);
+};
+const getGetPermissionUrl = (permissionId) => {
+	return `/access-control/permissions/${permissionId}`;
+};
+/**
+* Retrieves a permission by its ID.
+* @summary Get permission by ID
+*/
+const getPermission = async (permissionId, options) => {
+	return customFetch(getGetPermissionUrl(permissionId), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetPermissionQueryKey = (permissionId) => {
+	return [`/access-control/permissions/${permissionId}`];
+};
+const getGetPermissionQueryOptions = (permissionId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetPermissionQueryKey(permissionId);
+	const queryFn = ({ signal }) => getPermission(permissionId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: permissionId !== null && permissionId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get permission by ID
+*/
+function useGetPermission(permissionId, options, queryClient) {
+	const queryOptions = getGetPermissionQueryOptions(permissionId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$13(query, queryOptions.queryKey);
+}
+const getDeletePermissionUrl = (permissionId) => {
+	return `/access-control/permissions/${permissionId}`;
+};
+/**
+* Deletes a permission.
+* @summary Delete permission
+*/
+const deletePermission = async (permissionId, options) => {
+	return customFetch(getDeletePermissionUrl(permissionId), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getDeletePermissionMutationOptions = (options) => {
+	const mutationKey = ["deletePermission"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { permissionId } = props ?? {};
+		return deletePermission(permissionId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Delete permission
+*/
+const useDeletePermission = (options, queryClient) => {
+	return useMutation(getDeletePermissionMutationOptions(options), queryClient);
+};
+const getUpdatePermissionUrl = (permissionId) => {
+	return `/access-control/permissions/${permissionId}`;
+};
+/**
+* Updates a permission's description.
+* @summary Update permission
+*/
+const updatePermission = async (permissionId, updatePermissionRequest, options) => {
+	return customFetch(getUpdatePermissionUrl(permissionId), {
+		...options,
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(updatePermissionRequest)
+	});
+};
+const getUpdatePermissionMutationOptions = (options) => {
+	const mutationKey = ["updatePermission"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { permissionId, data } = props ?? {};
+		return updatePermission(permissionId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Update permission
+*/
+const useUpdatePermission = (options, queryClient) => {
+	return useMutation(getUpdatePermissionMutationOptions(options), queryClient);
+};
+const getListRolesUrl = () => {
+	return `/access-control/roles`;
+};
+/**
+* Lists all roles.
+* @summary List roles
+*/
+const listRoles = async (options) => {
+	return customFetch(getListRolesUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getListRolesQueryKey = () => {
+	return [`/access-control/roles`];
+};
+const getListRolesQueryOptions = (options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListRolesQueryKey();
+	const queryFn = ({ signal }) => listRoles({
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List roles
+*/
+function useListRoles(options, queryClient) {
+	const queryOptions = getListRolesQueryOptions(options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$13(query, queryOptions.queryKey);
+}
+const getCreateRoleUrl = () => {
+	return `/access-control/roles`;
+};
+/**
+* Creates a new role.
+* @summary Create role
+*/
+const createRole = async (createRoleRequest, options) => {
+	return customFetch(getCreateRoleUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createRoleRequest)
+	});
+};
+const getCreateRoleMutationOptions = (options) => {
+	const mutationKey = ["createRole"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return createRole(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Create role
+*/
+const useCreateRole = (options, queryClient) => {
+	return useMutation(getCreateRoleMutationOptions(options), queryClient);
+};
+const getGetRoleByNameUrl = (roleName) => {
+	return `/access-control/roles/by-name/${roleName}`;
+};
+/**
+* Retrieves a role by its name.
+* @summary Get role by name
+*/
+const getRoleByName = async (roleName, options) => {
+	return customFetch(getGetRoleByNameUrl(roleName), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetRoleByNameQueryKey = (roleName) => {
+	return [`/access-control/roles/by-name/${roleName}`];
+};
+const getGetRoleByNameQueryOptions = (roleName, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetRoleByNameQueryKey(roleName);
+	const queryFn = ({ signal }) => getRoleByName(roleName, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: roleName !== null && roleName !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get role by name
+*/
+function useGetRoleByName(roleName, options, queryClient) {
+	const queryOptions = getGetRoleByNameQueryOptions(roleName, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$13(query, queryOptions.queryKey);
+}
+const getGetRoleUrl = (roleId) => {
+	return `/access-control/roles/${roleId}`;
+};
+/**
+* Retrieves a role by its ID, including its permissions.
+* @summary Get role by ID
+*/
+const getRole = async (roleId, options) => {
+	return customFetch(getGetRoleUrl(roleId), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetRoleQueryKey = (roleId) => {
+	return [`/access-control/roles/${roleId}`];
+};
+const getGetRoleQueryOptions = (roleId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetRoleQueryKey(roleId);
+	const queryFn = ({ signal }) => getRole(roleId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: roleId !== null && roleId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get role by ID
+*/
+function useGetRole(roleId, options, queryClient) {
+	const queryOptions = getGetRoleQueryOptions(roleId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$13(query, queryOptions.queryKey);
+}
+const getDeleteRoleUrl = (roleId) => {
+	return `/access-control/roles/${roleId}`;
+};
+/**
+* Deletes a role.
+* @summary Delete role
+*/
+const deleteRole = async (roleId, options) => {
+	return customFetch(getDeleteRoleUrl(roleId), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getDeleteRoleMutationOptions = (options) => {
+	const mutationKey = ["deleteRole"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { roleId } = props ?? {};
+		return deleteRole(roleId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Delete role
+*/
+const useDeleteRole = (options, queryClient) => {
+	return useMutation(getDeleteRoleMutationOptions(options), queryClient);
+};
+const getUpdateRoleUrl = (roleId) => {
+	return `/access-control/roles/${roleId}`;
+};
+/**
+* Updates a role's attributes.
+* @summary Update role
+*/
+const updateRole = async (roleId, updateRoleRequest, options) => {
+	return customFetch(getUpdateRoleUrl(roleId), {
+		...options,
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(updateRoleRequest)
+	});
+};
+const getUpdateRoleMutationOptions = (options) => {
+	const mutationKey = ["updateRole"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { roleId, data } = props ?? {};
+		return updateRole(roleId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Update role
+*/
+const useUpdateRole = (options, queryClient) => {
+	return useMutation(getUpdateRoleMutationOptions(options), queryClient);
+};
+const getListRolePermissionsUrl = (roleId) => {
+	return `/access-control/roles/${roleId}/permissions`;
+};
+/**
+* Lists all permissions assigned to a role.
+* @summary List role permissions
+*/
+const listRolePermissions = async (roleId, options) => {
+	return customFetch(getListRolePermissionsUrl(roleId), {
+		...options,
+		method: "GET"
+	});
+};
+const getListRolePermissionsQueryKey = (roleId) => {
+	return [`/access-control/roles/${roleId}/permissions`];
+};
+const getListRolePermissionsQueryOptions = (roleId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListRolePermissionsQueryKey(roleId);
+	const queryFn = ({ signal }) => listRolePermissions(roleId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: roleId !== null && roleId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary List role permissions
+*/
+function useListRolePermissions(roleId, options, queryClient) {
+	const queryOptions = getListRolePermissionsQueryOptions(roleId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$13(query, queryOptions.queryKey);
+}
+const getReplaceRolePermissionsUrl = (roleId) => {
+	return `/access-control/roles/${roleId}/permissions`;
+};
+/**
+* Replaces all permissions assigned to a role with a new set.
+* @summary Replace role permissions
+*/
+const replaceRolePermissions = async (roleId, replaceRolePermissionsRequest, options) => {
+	return customFetch(getReplaceRolePermissionsUrl(roleId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(replaceRolePermissionsRequest)
+	});
+};
+const getReplaceRolePermissionsMutationOptions = (options) => {
+	const mutationKey = ["replaceRolePermissions"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { roleId, data } = props ?? {};
+		return replaceRolePermissions(roleId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Replace role permissions
+*/
+const useReplaceRolePermissions = (options, queryClient) => {
+	return useMutation(getReplaceRolePermissionsMutationOptions(options), queryClient);
+};
+const getAddRolePermissionUrl = (roleId) => {
+	return `/access-control/roles/${roleId}/permissions`;
+};
+/**
+* Assigns a permission to a role.
+* @summary Assign permission to role
+*/
+const addRolePermission = async (roleId, addRolePermissionRequest, options) => {
+	return customFetch(getAddRolePermissionUrl(roleId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(addRolePermissionRequest)
+	});
+};
+const getAddRolePermissionMutationOptions = (options) => {
+	const mutationKey = ["addRolePermission"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { roleId, data } = props ?? {};
+		return addRolePermission(roleId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Assign permission to role
+*/
+const useAddRolePermission = (options, queryClient) => {
+	return useMutation(getAddRolePermissionMutationOptions(options), queryClient);
+};
+const getRemoveRolePermissionUrl = (roleId, permissionId) => {
+	return `/access-control/roles/${roleId}/permissions/${permissionId}`;
+};
+/**
+* Removes a permission from a role.
+* @summary Remove role permission
+*/
+const removeRolePermission = async (roleId, permissionId, options) => {
+	return customFetch(getRemoveRolePermissionUrl(roleId, permissionId), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getRemoveRolePermissionMutationOptions = (options) => {
+	const mutationKey = ["removeRolePermission"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { roleId, permissionId } = props ?? {};
+		return removeRolePermission(roleId, permissionId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Remove role permission
+*/
+const useRemoveRolePermission = (options, queryClient) => {
+	return useMutation(getRemoveRolePermissionMutationOptions(options), queryClient);
+};
+const getGetUserPermissionsUrl = (userId) => {
+	return `/access-control/users/${userId}/permissions`;
+};
+/**
+* Retrieves all permissions granted to a user through their roles.
+* @summary Get user permissions
+*/
+const getUserPermissions = async (userId, options) => {
+	return customFetch(getGetUserPermissionsUrl(userId), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetUserPermissionsQueryKey = (userId) => {
+	return [`/access-control/users/${userId}/permissions`];
+};
+const getGetUserPermissionsQueryOptions = (userId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetUserPermissionsQueryKey(userId);
+	const queryFn = ({ signal }) => getUserPermissions(userId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: userId !== null && userId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get user permissions
+*/
+function useGetUserPermissions(userId, options, queryClient) {
+	const queryOptions = getGetUserPermissionsQueryOptions(userId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$13(query, queryOptions.queryKey);
+}
+const getCheckUserPermissionsUrl = (userId) => {
+	return `/access-control/users/${userId}/permissions/check`;
+};
+/**
+* Checks whether a user has all the specified permissions.
+* @summary Check user permissions
+*/
+const checkUserPermissions = async (userId, checkUserPermissionsRequest, options) => {
+	return customFetch(getCheckUserPermissionsUrl(userId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(checkUserPermissionsRequest)
+	});
+};
+const getCheckUserPermissionsMutationOptions = (options) => {
+	const mutationKey = ["checkUserPermissions"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId, data } = props ?? {};
+		return checkUserPermissions(userId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Check user permissions
+*/
+const useCheckUserPermissions = (options, queryClient) => {
+	return useMutation(getCheckUserPermissionsMutationOptions(options), queryClient);
+};
+const getListUserRolesUrl = (userId) => {
+	return `/access-control/users/${userId}/roles`;
+};
+/**
+* Lists all roles assigned to a user.
+* @summary List user roles
+*/
+const listUserRoles = async (userId, options) => {
+	return customFetch(getListUserRolesUrl(userId), {
+		...options,
+		method: "GET"
+	});
+};
+const getListUserRolesQueryKey = (userId) => {
+	return [`/access-control/users/${userId}/roles`];
+};
+const getListUserRolesQueryOptions = (userId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListUserRolesQueryKey(userId);
+	const queryFn = ({ signal }) => listUserRoles(userId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: userId !== null && userId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary List user roles
+*/
+function useListUserRoles(userId, options, queryClient) {
+	const queryOptions = getListUserRolesQueryOptions(userId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$13(query, queryOptions.queryKey);
+}
+const getReplaceUserRolesUrl = (userId) => {
+	return `/access-control/users/${userId}/roles`;
+};
+/**
+* Replaces all roles assigned to a user with a new set.
+* @summary Replace user roles
+*/
+const replaceUserRoles = async (userId, replaceUserRolesRequest, options) => {
+	return customFetch(getReplaceUserRolesUrl(userId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(replaceUserRolesRequest)
+	});
+};
+const getReplaceUserRolesMutationOptions = (options) => {
+	const mutationKey = ["replaceUserRoles"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId, data } = props ?? {};
+		return replaceUserRoles(userId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Replace user roles
+*/
+const useReplaceUserRoles = (options, queryClient) => {
+	return useMutation(getReplaceUserRolesMutationOptions(options), queryClient);
+};
+const getAssignUserRoleUrl = (userId) => {
+	return `/access-control/users/${userId}/roles`;
+};
+/**
+* Assigns a role to a user.
+* @summary Assign role to user
+*/
+const assignUserRole = async (userId, assignUserRoleRequest, options) => {
+	return customFetch(getAssignUserRoleUrl(userId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(assignUserRoleRequest)
+	});
+};
+const getAssignUserRoleMutationOptions = (options) => {
+	const mutationKey = ["assignUserRole"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId, data } = props ?? {};
+		return assignUserRole(userId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Assign role to user
+*/
+const useAssignUserRole = (options, queryClient) => {
+	return useMutation(getAssignUserRoleMutationOptions(options), queryClient);
+};
+const getRemoveUserRoleUrl = (userId, roleId) => {
+	return `/access-control/users/${userId}/roles/${roleId}`;
+};
+/**
+* Removes a role from a user.
+* @summary Remove user role
+*/
+const removeUserRole = async (userId, roleId, options) => {
+	return customFetch(getRemoveUserRoleUrl(userId, roleId), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getRemoveUserRoleMutationOptions = (options) => {
+	const mutationKey = ["removeUserRole"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId, roleId } = props ?? {};
+		return removeUserRole(userId, roleId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Remove user role
+*/
+const useRemoveUserRole = (options, queryClient) => {
+	return useMutation(getRemoveUserRoleMutationOptions(options), queryClient);
+};
+
+//#endregion
 //#region src/plugins/access-control/plugin.ts
 var AccessControlPlugin = class {
 	id = "accessControl";
 	constructor() {}
 	init(client) {
-		return {
-			createRole: async (data) => {
-				return wrappedFetch(client, `/access-control/roles`, {
-					method: "POST",
-					body: data
-				});
-			},
-			getAllRoles: async () => {
-				return wrappedFetch(client, `/access-control/roles`, { method: "GET" });
-			},
-			getRoleByName: async (roleName) => {
-				return wrappedFetch(client, `/access-control/roles/by-name/${roleName}`, { method: "GET" });
-			},
-			getRoleById: async (roleId) => {
-				return wrappedFetch(client, `/access-control/roles/${roleId}`, { method: "GET" });
-			},
-			updateRole: async (roleId, data) => {
-				return wrappedFetch(client, `/access-control/roles/${roleId}`, {
-					method: "PATCH",
-					body: data
-				});
-			},
-			deleteRole: async (roleId) => {
-				return wrappedFetch(client, `/access-control/roles/${roleId}`, { method: "DELETE" });
-			},
-			createPermission: async (data) => {
-				return wrappedFetch(client, `/access-control/permissions`, {
-					method: "POST",
-					body: data
-				});
-			},
-			getAllPermissions: async () => {
-				return wrappedFetch(client, `/access-control/permissions`, { method: "GET" });
-			},
-			getPermissionById: async (permissionId) => {
-				return wrappedFetch(client, `/access-control/permissions/${permissionId}`, { method: "GET" });
-			},
-			updatePermission: async (permissionId, data) => {
-				return wrappedFetch(client, `/access-control/permissions/${permissionId}`, {
-					method: "PATCH",
-					body: data
-				});
-			},
-			deletePermission: async (permissionId) => {
-				return wrappedFetch(client, `/access-control/permissions/${permissionId}`, { method: "DELETE" });
-			},
-			addRolePermission: async (roleId, data) => {
-				return wrappedFetch(client, `/access-control/roles/${roleId}/permissions`, {
-					method: "POST",
-					body: data
-				});
-			},
-			getRolePermissions: async (roleId) => {
-				return wrappedFetch(client, `/access-control/roles/${roleId}/permissions`, { method: "GET" });
-			},
-			replaceRolePermissions: async (roleId, data) => {
-				return wrappedFetch(client, `/access-control/roles/${roleId}/permissions`, {
-					method: "PUT",
-					body: data
-				});
-			},
-			removeRolePermission: async (roleId, permissionId) => {
-				return wrappedFetch(client, `/access-control/roles/${roleId}/permissions/${permissionId}`, { method: "DELETE" });
-			},
-			getUserRoles: async (userId) => {
-				return wrappedFetch(client, `/access-control/users/${userId}/roles`, { method: "GET" });
-			},
-			assignUserRole: async (userId, data) => {
-				return wrappedFetch(client, `/access-control/users/${userId}/roles`, {
-					method: "POST",
-					body: data
-				});
-			},
-			replaceUserRoles: async (userId, data) => {
-				return wrappedFetch(client, `/access-control/users/${userId}/roles`, {
-					method: "PUT",
-					body: data
-				});
-			},
-			removeUserRole: async (userId, roleId) => {
-				return wrappedFetch(client, `/access-control/users/${userId}/roles/${roleId}`, { method: "DELETE" });
-			},
-			getUserPermissions: async (userId) => {
-				return wrappedFetch(client, `/access-control/users/${userId}/permissions`, { method: "GET" });
-			},
-			checkUserPermissions: async (userId, data) => {
-				return wrappedFetch(client, `/access-control/users/${userId}/permissions/check`, {
-					method: "POST",
-					body: data
-				});
-			}
-		};
+		return wrapGenerated(access_control_exports, client);
 	}
 };
 
 //#endregion
-//#region src/plugins/access-control/types.ts
-const roleSchema = z.object({
-	id: z.string().nonempty(),
-	name: z.string().nonempty(),
-	description: z.string().nullish(),
-	weight: z.number(),
-	isSystem: z.boolean(),
-	createdAt: z.iso.datetime(),
-	updatedAt: z.iso.datetime()
+//#region src/gen/endpoints/admin-accounts/admin-accounts.ts
+var admin_accounts_exports = /* @__PURE__ */ __exportAll({
+	createAccount: () => createAccount,
+	deleteAccount: () => deleteAccount,
+	getAccount: () => getAccount,
+	getCreateAccountMutationOptions: () => getCreateAccountMutationOptions,
+	getCreateAccountUrl: () => getCreateAccountUrl,
+	getDeleteAccountMutationOptions: () => getDeleteAccountMutationOptions,
+	getDeleteAccountUrl: () => getDeleteAccountUrl,
+	getGetAccountQueryKey: () => getGetAccountQueryKey,
+	getGetAccountQueryOptions: () => getGetAccountQueryOptions,
+	getGetAccountUrl: () => getGetAccountUrl,
+	getListUserAccountsQueryKey: () => getListUserAccountsQueryKey,
+	getListUserAccountsQueryOptions: () => getListUserAccountsQueryOptions,
+	getListUserAccountsUrl: () => getListUserAccountsUrl,
+	getUpdateAccountMutationOptions: () => getUpdateAccountMutationOptions,
+	getUpdateAccountUrl: () => getUpdateAccountUrl,
+	listUserAccounts: () => listUserAccounts,
+	updateAccount: () => updateAccount,
+	useCreateAccount: () => useCreateAccount,
+	useDeleteAccount: () => useDeleteAccount,
+	useGetAccount: () => useGetAccount,
+	useListUserAccounts: () => useListUserAccounts,
+	useUpdateAccount: () => useUpdateAccount
 });
-const permissionSchema = z.object({
-	id: z.string().nonempty(),
-	key: z.string().nonempty(),
-	description: z.string().nullish(),
-	isSystem: z.boolean(),
-	createdAt: z.iso.datetime(),
-	updatedAt: z.iso.datetime()
-});
-const permissionGrantSourceSchema = z.object({
-	roleId: z.string().nonempty(),
-	roleName: z.string().nonempty(),
-	grantedByUserId: z.string().nullish(),
-	grantedAt: z.iso.datetime().nullish()
+const withQueryKey$12 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getGetAccountUrl = (id) => {
+	return `/admin/accounts/${id}`;
+};
+/**
+* Retrieves an account by its ID.
+* @summary Get account by ID
+*/
+const getAccount = async (id, options) => {
+	return customFetch(getGetAccountUrl(id), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetAccountQueryKey = (id) => {
+	return [`/admin/accounts/${id}`];
+};
+const getGetAccountQueryOptions = (id, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetAccountQueryKey(id);
+	const queryFn = ({ signal }) => getAccount(id, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: id !== null && id !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get account by ID
+*/
+function useGetAccount(id, options, queryClient) {
+	const queryOptions = getGetAccountQueryOptions(id, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$12(query, queryOptions.queryKey);
+}
+const getDeleteAccountUrl = (id) => {
+	return `/admin/accounts/${id}`;
+};
+/**
+* Deletes an account.
+* @summary Delete account
+*/
+const deleteAccount = async (id, options) => {
+	return customFetch(getDeleteAccountUrl(id), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getDeleteAccountMutationOptions = (options) => {
+	const mutationKey = ["deleteAccount"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { id } = props ?? {};
+		return deleteAccount(id, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Delete account
+*/
+const useDeleteAccount = (options, queryClient) => {
+	return useMutation(getDeleteAccountMutationOptions(options), queryClient);
+};
+const getUpdateAccountUrl = (id) => {
+	return `/admin/accounts/${id}`;
+};
+/**
+* Updates an account's attributes.
+* @summary Update account
+*/
+const updateAccount = async (id, updateAccountRequest, options) => {
+	return customFetch(getUpdateAccountUrl(id), {
+		...options,
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(updateAccountRequest)
+	});
+};
+const getUpdateAccountMutationOptions = (options) => {
+	const mutationKey = ["updateAccount"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { id, data } = props ?? {};
+		return updateAccount(id, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Update account
+*/
+const useUpdateAccount = (options, queryClient) => {
+	return useMutation(getUpdateAccountMutationOptions(options), queryClient);
+};
+const getListUserAccountsUrl = (userId) => {
+	return `/admin/users/${userId}/accounts`;
+};
+/**
+* Lists all accounts for a user.
+* @summary List user accounts
+*/
+const listUserAccounts = async (userId, options) => {
+	return customFetch(getListUserAccountsUrl(userId), {
+		...options,
+		method: "GET"
+	});
+};
+const getListUserAccountsQueryKey = (userId) => {
+	return [`/admin/users/${userId}/accounts`];
+};
+const getListUserAccountsQueryOptions = (userId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListUserAccountsQueryKey(userId);
+	const queryFn = ({ signal }) => listUserAccounts(userId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: userId !== null && userId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary List user accounts
+*/
+function useListUserAccounts(userId, options, queryClient) {
+	const queryOptions = getListUserAccountsQueryOptions(userId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$12(query, queryOptions.queryKey);
+}
+const getCreateAccountUrl = (userId) => {
+	return `/admin/users/${userId}/accounts`;
+};
+/**
+* Creates a new account for a user.
+* @summary Create account
+*/
+const createAccount = async (userId, createAccountRequest, options) => {
+	return customFetch(getCreateAccountUrl(userId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createAccountRequest)
+	});
+};
+const getCreateAccountMutationOptions = (options) => {
+	const mutationKey = ["createAccount"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId, data } = props ?? {};
+		return createAccount(userId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Create account
+*/
+const useCreateAccount = (options, queryClient) => {
+	return useMutation(getCreateAccountMutationOptions(options), queryClient);
+};
+
+//#endregion
+//#region src/gen/endpoints/admin-impersonation/admin-impersonation.ts
+var admin_impersonation_exports = /* @__PURE__ */ __exportAll({
+	getGetImpersonationQueryKey: () => getGetImpersonationQueryKey,
+	getGetImpersonationQueryOptions: () => getGetImpersonationQueryOptions,
+	getGetImpersonationUrl: () => getGetImpersonationUrl,
+	getImpersonation: () => getImpersonation,
+	getListImpersonationsQueryKey: () => getListImpersonationsQueryKey,
+	getListImpersonationsQueryOptions: () => getListImpersonationsQueryOptions,
+	getListImpersonationsUrl: () => getListImpersonationsUrl,
+	getStartImpersonationMutationOptions: () => getStartImpersonationMutationOptions,
+	getStartImpersonationUrl: () => getStartImpersonationUrl,
+	getStopImpersonationMutationOptions: () => getStopImpersonationMutationOptions,
+	getStopImpersonationUrl: () => getStopImpersonationUrl,
+	listImpersonations: () => listImpersonations,
+	startImpersonation: () => startImpersonation,
+	stopImpersonation: () => stopImpersonation,
+	useGetImpersonation: () => useGetImpersonation,
+	useListImpersonations: () => useListImpersonations,
+	useStartImpersonation: () => useStartImpersonation,
+	useStopImpersonation: () => useStopImpersonation
 });
-const userPermissionInfoSchema = z.object({
-	permissionId: z.string().nonempty(),
-	permissionKey: z.string().nonempty(),
-	permissionDescription: z.string().nullish(),
-	grantedByUserId: z.string().nullish(),
-	grantedAt: z.iso.datetime().nullish(),
-	sources: z.array(permissionGrantSourceSchema).optional()
+const withQueryKey$11 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getListImpersonationsUrl = () => {
+	return `/admin/impersonations`;
+};
+/**
+* Lists all impersonations.
+* @summary List impersonations
+*/
+const listImpersonations = async (options) => {
+	return customFetch(getListImpersonationsUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getListImpersonationsQueryKey = () => {
+	return [`/admin/impersonations`];
+};
+const getListImpersonationsQueryOptions = (options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListImpersonationsQueryKey();
+	const queryFn = ({ signal }) => listImpersonations({
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List impersonations
+*/
+function useListImpersonations(options, queryClient) {
+	const queryOptions = getListImpersonationsQueryOptions(options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$11(query, queryOptions.queryKey);
+}
+const getStartImpersonationUrl = () => {
+	return `/admin/impersonations`;
+};
+/**
+* Starts an impersonation session as a target user.
+* @summary Start impersonation
+*/
+const startImpersonation = async (startImpersonationRequest, options) => {
+	return customFetch(getStartImpersonationUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(startImpersonationRequest)
+	});
+};
+const getStartImpersonationMutationOptions = (options) => {
+	const mutationKey = ["startImpersonation"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return startImpersonation(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Start impersonation
+*/
+const useStartImpersonation = (options, queryClient) => {
+	return useMutation(getStartImpersonationMutationOptions(options), queryClient);
+};
+const getGetImpersonationUrl = (impersonationId) => {
+	return `/admin/impersonations/${impersonationId}`;
+};
+/**
+* Retrieves an impersonation by its ID.
+* @summary Get impersonation by ID
+*/
+const getImpersonation = async (impersonationId, options) => {
+	return customFetch(getGetImpersonationUrl(impersonationId), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetImpersonationQueryKey = (impersonationId) => {
+	return [`/admin/impersonations/${impersonationId}`];
+};
+const getGetImpersonationQueryOptions = (impersonationId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetImpersonationQueryKey(impersonationId);
+	const queryFn = ({ signal }) => getImpersonation(impersonationId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: impersonationId !== null && impersonationId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get impersonation by ID
+*/
+function useGetImpersonation(impersonationId, options, queryClient) {
+	const queryOptions = getGetImpersonationQueryOptions(impersonationId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$11(query, queryOptions.queryKey);
+}
+const getStopImpersonationUrl = (impersonationId) => {
+	return `/admin/impersonations/${impersonationId}/stop`;
+};
+/**
+* Stops an impersonation session and restores the original session.
+* @summary Stop impersonation
+*/
+const stopImpersonation = async (impersonationId, options) => {
+	return customFetch(getStopImpersonationUrl(impersonationId), {
+		...options,
+		method: "POST"
+	});
+};
+const getStopImpersonationMutationOptions = (options) => {
+	const mutationKey = ["stopImpersonation"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { impersonationId } = props ?? {};
+		return stopImpersonation(impersonationId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Stop impersonation
+*/
+const useStopImpersonation = (options, queryClient) => {
+	return useMutation(getStopImpersonationMutationOptions(options), queryClient);
+};
+
+//#endregion
+//#region src/gen/endpoints/admin-session-state/admin-session-state.ts
+var admin_session_state_exports = /* @__PURE__ */ __exportAll({
+	createSessionState: () => createSessionState,
+	deleteSessionState: () => deleteSessionState,
+	getCreateSessionStateMutationOptions: () => getCreateSessionStateMutationOptions,
+	getCreateSessionStateUrl: () => getCreateSessionStateUrl,
+	getDeleteSessionStateMutationOptions: () => getDeleteSessionStateMutationOptions,
+	getDeleteSessionStateUrl: () => getDeleteSessionStateUrl,
+	getGetSessionStateQueryKey: () => getGetSessionStateQueryKey,
+	getGetSessionStateQueryOptions: () => getGetSessionStateQueryOptions,
+	getGetSessionStateUrl: () => getGetSessionStateUrl,
+	getListRevokedSessionStatesQueryKey: () => getListRevokedSessionStatesQueryKey,
+	getListRevokedSessionStatesQueryOptions: () => getListRevokedSessionStatesQueryOptions,
+	getListRevokedSessionStatesUrl: () => getListRevokedSessionStatesUrl,
+	getRevokeSessionMutationOptions: () => getRevokeSessionMutationOptions,
+	getRevokeSessionUrl: () => getRevokeSessionUrl,
+	getSessionState: () => getSessionState,
+	getUpdateSessionStateMutationOptions: () => getUpdateSessionStateMutationOptions,
+	getUpdateSessionStateUrl: () => getUpdateSessionStateUrl,
+	listRevokedSessionStates: () => listRevokedSessionStates,
+	revokeSession: () => revokeSession,
+	updateSessionState: () => updateSessionState,
+	useCreateSessionState: () => useCreateSessionState,
+	useDeleteSessionState: () => useDeleteSessionState,
+	useGetSessionState: () => useGetSessionState,
+	useListRevokedSessionStates: () => useListRevokedSessionStates,
+	useRevokeSession: () => useRevokeSession,
+	useUpdateSessionState: () => useUpdateSessionState
 });
-const userRoleInfoSchema = z.object({
-	roleId: z.string().nonempty(),
-	roleName: z.string().nonempty(),
-	roleDescription: z.string().nullish(),
-	assignedByUserId: z.string().nullish(),
-	assignedAt: z.iso.datetime().nullish(),
-	expiresAt: z.iso.datetime().nullish()
+const withQueryKey$10 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getListRevokedSessionStatesUrl = () => {
+	return `/admin/sessions/states/revoked`;
+};
+/**
+* Lists all revoked session states.
+* @summary List revoked session states
+*/
+const listRevokedSessionStates = async (options) => {
+	return customFetch(getListRevokedSessionStatesUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getListRevokedSessionStatesQueryKey = () => {
+	return [`/admin/sessions/states/revoked`];
+};
+const getListRevokedSessionStatesQueryOptions = (options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListRevokedSessionStatesQueryKey();
+	const queryFn = ({ signal }) => listRevokedSessionStates({
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List revoked session states
+*/
+function useListRevokedSessionStates(options, queryClient) {
+	const queryOptions = getListRevokedSessionStatesQueryOptions(options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$10(query, queryOptions.queryKey);
+}
+const getRevokeSessionUrl = (sessionId) => {
+	return `/admin/sessions/${sessionId}/revoke`;
+};
+/**
+* Revokes a session.
+* @summary Revoke session
+*/
+const revokeSession = async (sessionId, revokeSessionRequest, options) => {
+	return customFetch(getRevokeSessionUrl(sessionId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(revokeSessionRequest)
+	});
+};
+const getRevokeSessionMutationOptions = (options) => {
+	const mutationKey = ["revokeSession"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { sessionId, data } = props ?? {};
+		return revokeSession(sessionId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Revoke session
+*/
+const useRevokeSession = (options, queryClient) => {
+	return useMutation(getRevokeSessionMutationOptions(options), queryClient);
+};
+const getGetSessionStateUrl = (sessionId) => {
+	return `/admin/sessions/${sessionId}/state`;
+};
+/**
+* Retrieves the state of a session.
+* @summary Get session state
+*/
+const getSessionState = async (sessionId, options) => {
+	return customFetch(getGetSessionStateUrl(sessionId), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetSessionStateQueryKey = (sessionId) => {
+	return [`/admin/sessions/${sessionId}/state`];
+};
+const getGetSessionStateQueryOptions = (sessionId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetSessionStateQueryKey(sessionId);
+	const queryFn = ({ signal }) => getSessionState(sessionId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: sessionId !== null && sessionId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get session state
+*/
+function useGetSessionState(sessionId, options, queryClient) {
+	const queryOptions = getGetSessionStateQueryOptions(sessionId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$10(query, queryOptions.queryKey);
+}
+const getCreateSessionStateUrl = (sessionId) => {
+	return `/admin/sessions/${sessionId}/state`;
+};
+/**
+* Creates the state for a session.
+* @summary Create session state
+*/
+const createSessionState = async (sessionId, createSessionStateRequest, options) => {
+	return customFetch(getCreateSessionStateUrl(sessionId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createSessionStateRequest)
+	});
+};
+const getCreateSessionStateMutationOptions = (options) => {
+	const mutationKey = ["createSessionState"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { sessionId, data } = props ?? {};
+		return createSessionState(sessionId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Create session state
+*/
+const useCreateSessionState = (options, queryClient) => {
+	return useMutation(getCreateSessionStateMutationOptions(options), queryClient);
+};
+const getDeleteSessionStateUrl = (sessionId) => {
+	return `/admin/sessions/${sessionId}/state`;
+};
+/**
+* Deletes the state of a session.
+* @summary Delete session state
+*/
+const deleteSessionState = async (sessionId, options) => {
+	return customFetch(getDeleteSessionStateUrl(sessionId), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getDeleteSessionStateMutationOptions = (options) => {
+	const mutationKey = ["deleteSessionState"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { sessionId } = props ?? {};
+		return deleteSessionState(sessionId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Delete session state
+*/
+const useDeleteSessionState = (options, queryClient) => {
+	return useMutation(getDeleteSessionStateMutationOptions(options), queryClient);
+};
+const getUpdateSessionStateUrl = (sessionId) => {
+	return `/admin/sessions/${sessionId}/state`;
+};
+/**
+* Updates the state of a session.
+* @summary Update session state
+*/
+const updateSessionState = async (sessionId, upsertSessionStateRequest, options) => {
+	return customFetch(getUpdateSessionStateUrl(sessionId), {
+		...options,
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(upsertSessionStateRequest)
+	});
+};
+const getUpdateSessionStateMutationOptions = (options) => {
+	const mutationKey = ["updateSessionState"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { sessionId, data } = props ?? {};
+		return updateSessionState(sessionId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Update session state
+*/
+const useUpdateSessionState = (options, queryClient) => {
+	return useMutation(getUpdateSessionStateMutationOptions(options), queryClient);
+};
+
+//#endregion
+//#region src/gen/endpoints/admin-user-state/admin-user-state.ts
+var admin_user_state_exports = /* @__PURE__ */ __exportAll({
+	banUser: () => banUser,
+	createUserState: () => createUserState,
+	deleteUserState: () => deleteUserState,
+	getBanUserMutationOptions: () => getBanUserMutationOptions,
+	getBanUserUrl: () => getBanUserUrl,
+	getCreateUserStateMutationOptions: () => getCreateUserStateMutationOptions,
+	getCreateUserStateUrl: () => getCreateUserStateUrl,
+	getDeleteUserStateMutationOptions: () => getDeleteUserStateMutationOptions,
+	getDeleteUserStateUrl: () => getDeleteUserStateUrl,
+	getGetUserStateQueryKey: () => getGetUserStateQueryKey,
+	getGetUserStateQueryOptions: () => getGetUserStateQueryOptions,
+	getGetUserStateUrl: () => getGetUserStateUrl,
+	getListBannedUserStatesQueryKey: () => getListBannedUserStatesQueryKey,
+	getListBannedUserStatesQueryOptions: () => getListBannedUserStatesQueryOptions,
+	getListBannedUserStatesUrl: () => getListBannedUserStatesUrl,
+	getListUserSessionsQueryKey: () => getListUserSessionsQueryKey,
+	getListUserSessionsQueryOptions: () => getListUserSessionsQueryOptions,
+	getListUserSessionsUrl: () => getListUserSessionsUrl,
+	getUnbanUserMutationOptions: () => getUnbanUserMutationOptions,
+	getUnbanUserUrl: () => getUnbanUserUrl,
+	getUpdateUserStateMutationOptions: () => getUpdateUserStateMutationOptions,
+	getUpdateUserStateUrl: () => getUpdateUserStateUrl,
+	getUserState: () => getUserState,
+	listBannedUserStates: () => listBannedUserStates,
+	listUserSessions: () => listUserSessions,
+	unbanUser: () => unbanUser,
+	updateUserState: () => updateUserState,
+	useBanUser: () => useBanUser,
+	useCreateUserState: () => useCreateUserState,
+	useDeleteUserState: () => useDeleteUserState,
+	useGetUserState: () => useGetUserState,
+	useListBannedUserStates: () => useListBannedUserStates,
+	useListUserSessions: () => useListUserSessions,
+	useUnbanUser: () => useUnbanUser,
+	useUpdateUserState: () => useUpdateUserState
 });
-const roleDetailsSchema = z.object({
-	role: roleSchema,
-	permissions: z.array(userPermissionInfoSchema)
+const withQueryKey$9 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getListBannedUserStatesUrl = () => {
+	return `/admin/users/states/banned`;
+};
+/**
+* Lists all banned user states.
+* @summary List banned user states
+*/
+const listBannedUserStates = async (options) => {
+	return customFetch(getListBannedUserStatesUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getListBannedUserStatesQueryKey = () => {
+	return [`/admin/users/states/banned`];
+};
+const getListBannedUserStatesQueryOptions = (options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListBannedUserStatesQueryKey();
+	const queryFn = ({ signal }) => listBannedUserStates({
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List banned user states
+*/
+function useListBannedUserStates(options, queryClient) {
+	const queryOptions = getListBannedUserStatesQueryOptions(options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$9(query, queryOptions.queryKey);
+}
+const getBanUserUrl = (userId) => {
+	return `/admin/users/${userId}/ban`;
+};
+/**
+* Bans a user.
+* @summary Ban user
+*/
+const banUser = async (userId, banUserRequest, options) => {
+	return customFetch(getBanUserUrl(userId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(banUserRequest)
+	});
+};
+const getBanUserMutationOptions = (options) => {
+	const mutationKey = ["banUser"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId, data } = props ?? {};
+		return banUser(userId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Ban user
+*/
+const useBanUser = (options, queryClient) => {
+	return useMutation(getBanUserMutationOptions(options), queryClient);
+};
+const getListUserSessionsUrl = (userId) => {
+	return `/admin/users/${userId}/sessions`;
+};
+/**
+* Lists all sessions for a user.
+* @summary List user sessions
+*/
+const listUserSessions = async (userId, options) => {
+	return customFetch(getListUserSessionsUrl(userId), {
+		...options,
+		method: "GET"
+	});
+};
+const getListUserSessionsQueryKey = (userId) => {
+	return [`/admin/users/${userId}/sessions`];
+};
+const getListUserSessionsQueryOptions = (userId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListUserSessionsQueryKey(userId);
+	const queryFn = ({ signal }) => listUserSessions(userId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: userId !== null && userId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary List user sessions
+*/
+function useListUserSessions(userId, options, queryClient) {
+	const queryOptions = getListUserSessionsQueryOptions(userId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$9(query, queryOptions.queryKey);
+}
+const getGetUserStateUrl = (userId) => {
+	return `/admin/users/${userId}/state`;
+};
+/**
+* Retrieves the state of a user.
+* @summary Get user state
+*/
+const getUserState = async (userId, options) => {
+	return customFetch(getGetUserStateUrl(userId), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetUserStateQueryKey = (userId) => {
+	return [`/admin/users/${userId}/state`];
+};
+const getGetUserStateQueryOptions = (userId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetUserStateQueryKey(userId);
+	const queryFn = ({ signal }) => getUserState(userId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: userId !== null && userId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get user state
+*/
+function useGetUserState(userId, options, queryClient) {
+	const queryOptions = getGetUserStateQueryOptions(userId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$9(query, queryOptions.queryKey);
+}
+const getCreateUserStateUrl = (userId) => {
+	return `/admin/users/${userId}/state`;
+};
+/**
+* Creates the state for a user.
+* @summary Create user state
+*/
+const createUserState = async (userId, createUserStateRequest, options) => {
+	return customFetch(getCreateUserStateUrl(userId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createUserStateRequest)
+	});
+};
+const getCreateUserStateMutationOptions = (options) => {
+	const mutationKey = ["createUserState"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId, data } = props ?? {};
+		return createUserState(userId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Create user state
+*/
+const useCreateUserState = (options, queryClient) => {
+	return useMutation(getCreateUserStateMutationOptions(options), queryClient);
+};
+const getDeleteUserStateUrl = (userId) => {
+	return `/admin/users/${userId}/state`;
+};
+/**
+* Deletes the state of a user.
+* @summary Delete user state
+*/
+const deleteUserState = async (userId, options) => {
+	return customFetch(getDeleteUserStateUrl(userId), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getDeleteUserStateMutationOptions = (options) => {
+	const mutationKey = ["deleteUserState"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId } = props ?? {};
+		return deleteUserState(userId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Delete user state
+*/
+const useDeleteUserState = (options, queryClient) => {
+	return useMutation(getDeleteUserStateMutationOptions(options), queryClient);
+};
+const getUpdateUserStateUrl = (userId) => {
+	return `/admin/users/${userId}/state`;
+};
+/**
+* Updates the state of a user.
+* @summary Update user state
+*/
+const updateUserState = async (userId, upsertUserStateRequest, options) => {
+	return customFetch(getUpdateUserStateUrl(userId), {
+		...options,
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(upsertUserStateRequest)
+	});
+};
+const getUpdateUserStateMutationOptions = (options) => {
+	const mutationKey = ["updateUserState"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId, data } = props ?? {};
+		return updateUserState(userId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Update user state
+*/
+const useUpdateUserState = (options, queryClient) => {
+	return useMutation(getUpdateUserStateMutationOptions(options), queryClient);
+};
+const getUnbanUserUrl = (userId) => {
+	return `/admin/users/${userId}/unban`;
+};
+/**
+* Unbans a user.
+* @summary Unban user
+*/
+const unbanUser = async (userId, options) => {
+	return customFetch(getUnbanUserUrl(userId), {
+		...options,
+		method: "POST"
+	});
+};
+const getUnbanUserMutationOptions = (options) => {
+	const mutationKey = ["unbanUser"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId } = props ?? {};
+		return unbanUser(userId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Unban user
+*/
+const useUnbanUser = (options, queryClient) => {
+	return useMutation(getUnbanUserMutationOptions(options), queryClient);
+};
+
+//#endregion
+//#region src/gen/endpoints/admin-users/admin-users.ts
+var admin_users_exports = /* @__PURE__ */ __exportAll({
+	createUser: () => createUser,
+	deleteUser: () => deleteUser,
+	getCreateUserMutationOptions: () => getCreateUserMutationOptions,
+	getCreateUserUrl: () => getCreateUserUrl,
+	getDeleteUserMutationOptions: () => getDeleteUserMutationOptions,
+	getDeleteUserUrl: () => getDeleteUserUrl,
+	getGetUserQueryKey: () => getGetUserQueryKey,
+	getGetUserQueryOptions: () => getGetUserQueryOptions,
+	getGetUserUrl: () => getGetUserUrl,
+	getListUsersQueryKey: () => getListUsersQueryKey,
+	getListUsersQueryOptions: () => getListUsersQueryOptions,
+	getListUsersUrl: () => getListUsersUrl,
+	getUpdateUserMutationOptions: () => getUpdateUserMutationOptions,
+	getUpdateUserUrl: () => getUpdateUserUrl,
+	getUser: () => getUser,
+	listUsers: () => listUsers,
+	updateUser: () => updateUser,
+	useCreateUser: () => useCreateUser,
+	useDeleteUser: () => useDeleteUser,
+	useGetUser: () => useGetUser,
+	useListUsers: () => useListUsers,
+	useUpdateUser: () => useUpdateUser
 });
-const getUserPermissionsResponseSchema = z.object({ permissions: z.array(userPermissionInfoSchema) });
-const checkUserPermissionsResponseSchema = z.object({ hasPermissions: z.boolean() });
+const withQueryKey$8 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getListUsersUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/admin/users?${stringifiedParams}` : `/admin/users`;
+};
+/**
+* Lists users with cursor-based pagination.
+* @summary List users
+*/
+const listUsers = async (params, options) => {
+	return customFetch(getListUsersUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getListUsersQueryKey = (params) => {
+	return [`/admin/users`, ...params ? [params] : []];
+};
+const getListUsersQueryOptions = (params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListUsersQueryKey(params);
+	const queryFn = ({ signal }) => listUsers(params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List users
+*/
+function useListUsers(params, options, queryClient) {
+	const queryOptions = getListUsersQueryOptions(params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$8(query, queryOptions.queryKey);
+}
+const getCreateUserUrl = () => {
+	return `/admin/users`;
+};
+/**
+* Creates a new user with the specified attributes.
+* @summary Create user
+*/
+const createUser = async (createUserRequest, options) => {
+	return customFetch(getCreateUserUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createUserRequest)
+	});
+};
+const getCreateUserMutationOptions = (options) => {
+	const mutationKey = ["createUser"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return createUser(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Create user
+*/
+const useCreateUser = (options, queryClient) => {
+	return useMutation(getCreateUserMutationOptions(options), queryClient);
+};
+const getGetUserUrl = (userId) => {
+	return `/admin/users/${userId}`;
+};
+/**
+* Retrieves a user by their ID.
+* @summary Get user by ID
+*/
+const getUser = async (userId, options) => {
+	return customFetch(getGetUserUrl(userId), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetUserQueryKey = (userId) => {
+	return [`/admin/users/${userId}`];
+};
+const getGetUserQueryOptions = (userId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetUserQueryKey(userId);
+	const queryFn = ({ signal }) => getUser(userId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: userId !== null && userId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get user by ID
+*/
+function useGetUser(userId, options, queryClient) {
+	const queryOptions = getGetUserQueryOptions(userId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$8(query, queryOptions.queryKey);
+}
+const getDeleteUserUrl = (userId) => {
+	return `/admin/users/${userId}`;
+};
+/**
+* Deletes a user.
+* @summary Delete user
+*/
+const deleteUser = async (userId, options) => {
+	return customFetch(getDeleteUserUrl(userId), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getDeleteUserMutationOptions = (options) => {
+	const mutationKey = ["deleteUser"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId } = props ?? {};
+		return deleteUser(userId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Delete user
+*/
+const useDeleteUser = (options, queryClient) => {
+	return useMutation(getDeleteUserMutationOptions(options), queryClient);
+};
+const getUpdateUserUrl = (userId) => {
+	return `/admin/users/${userId}`;
+};
+/**
+* Updates a user's attributes.
+* @summary Update user
+*/
+const updateUser = async (userId, updateUserRequest, options) => {
+	return customFetch(getUpdateUserUrl(userId), {
+		...options,
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(updateUserRequest)
+	});
+};
+const getUpdateUserMutationOptions = (options) => {
+	const mutationKey = ["updateUser"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { userId, data } = props ?? {};
+		return updateUser(userId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Update user
+*/
+const useUpdateUser = (options, queryClient) => {
+	return useMutation(getUpdateUserMutationOptions(options), queryClient);
+};
 
 //#endregion
 //#region src/plugins/admin/plugin.ts
@@ -157,170 +2402,322 @@ var AdminPlugin = class {
 	constructor() {}
 	init(client) {
 		return {
-			createUser: async (data) => {
-				return wrappedFetch(client, "/admin/users", {
-					method: "POST",
-					body: data
-				});
-			},
-			getAllUsers: async (limit) => {
-				const urlSearchParams = new URLSearchParams();
-				if (limit) urlSearchParams.append("limit", limit.toString());
-				return wrappedFetch(client, `/admin/users${urlSearchParams.toString() ? `?${urlSearchParams.toString()}` : ""}`, { method: "GET" });
-			},
-			getUserById: async (userId) => {
-				return wrappedFetch(client, `/admin/users/${userId}`, { method: "GET" });
-			},
-			updateUser: async (userId, data) => {
-				return wrappedFetch(client, `/admin/users/${userId}`, {
-					method: "PATCH",
-					body: data
-				});
-			},
-			deleteUser: async (userId) => {
-				return wrappedFetch(client, `/admin/users/${userId}`, { method: "DELETE" });
-			},
-			createAccount: async (userId, data) => {
-				return wrappedFetch(client, `/admin/users/${userId}/accounts`, {
-					method: "POST",
-					body: data
-				});
-			},
-			getUserAccounts: async (userId) => {
-				return wrappedFetch(client, `/admin/users/${userId}/accounts`, { method: "GET" });
-			},
-			getAccountById: async (id) => {
-				return wrappedFetch(client, `/admin/accounts/${id}`, { method: "GET" });
-			},
-			updateAccount: async (id, data) => {
-				return wrappedFetch(client, `/admin/accounts/${id}`, {
-					method: "PATCH",
-					body: data
-				});
-			},
-			deleteAccount: async (id) => {
-				return wrappedFetch(client, `/admin/accounts/${id}`, { method: "DELETE" });
-			},
-			getUserState: async (userId) => {
-				return wrappedFetch(client, `/admin/users/${userId}/state`, { method: "GET" });
-			},
-			createUserState: async (userId, data) => {
-				return wrappedFetch(client, `/admin/users/${userId}/state`, {
-					method: "POST",
-					body: data
-				});
-			},
-			updateUserState: async (userId, data) => {
-				return wrappedFetch(client, `/admin/users/${userId}/state`, {
-					method: "PATCH",
-					body: data
-				});
-			},
-			deleteUserState: async (userId) => {
-				return wrappedFetch(client, `/admin/users/${userId}/state`, { method: "DELETE" });
-			},
-			getBannedUserStates: async () => {
-				return wrappedFetch(client, `/admin/users/states/banned`, { method: "GET" });
-			},
-			banUser: async (userId, data) => {
-				return wrappedFetch(client, `/admin/users/${userId}/ban`, {
-					method: "POST",
-					body: data
-				});
-			},
-			unbanUser: async (userId) => {
-				return wrappedFetch(client, `/admin/users/${userId}/unban`, { method: "POST" });
-			},
-			getUserAdminSessions: async (userId) => {
-				return wrappedFetch(client, `/admin/users/${userId}/sessions`, { method: "GET" });
-			},
-			getSessionState: async (sessionId) => {
-				return wrappedFetch(client, `/admin/sessions/${sessionId}/state`, { method: "GET" });
-			},
-			createSessionState: async (sessionId, data) => {
-				return wrappedFetch(client, `/admin/sessions/${sessionId}/state`, {
-					method: "POST",
-					body: data
-				});
-			},
-			updateSessionState: async (sessionId, data) => {
-				return wrappedFetch(client, `/admin/sessions/${sessionId}/state`, {
-					method: "PATCH",
-					body: data
-				});
-			},
-			deleteSessionState: async (sessionId) => {
-				return wrappedFetch(client, `/admin/sessions/${sessionId}/state`, { method: "DELETE" });
-			},
-			getRevokedSessionStates: async () => {
-				return wrappedFetch(client, `/admin/sessions/states/revoked`, { method: "GET" });
-			},
-			revokeSession: async (sessionId, data) => {
-				return wrappedFetch(client, `/admin/sessions/${sessionId}/revoke`, {
-					method: "POST",
-					body: data
-				});
-			},
-			getAllImpersonations: async () => {
-				return wrappedFetch(client, "/admin/impersonations", { method: "GET" });
-			},
-			getImpersonationById: async (impersonationId) => {
-				return wrappedFetch(client, `/admin/impersonations/${impersonationId}`, { method: "GET" });
-			},
-			startImpersonation: async (data) => {
-				return wrappedFetch(client, "/admin/impersonations", {
-					method: "POST",
-					body: data
-				});
-			},
-			stopImpersonation: async (impersonationId) => {
-				return wrappedFetch(client, `/admin/impersonations/${impersonationId}/stop`, { method: "POST" });
-			}
+			...wrapGenerated(admin_users_exports, client),
+			...wrapGenerated(admin_accounts_exports, client),
+			...wrapGenerated(admin_user_state_exports, client),
+			...wrapGenerated(admin_session_state_exports, client),
+			...wrapGenerated(admin_impersonation_exports, client)
 		};
 	}
 };
 
 //#endregion
-//#region src/plugins/admin/types.ts
-const adminUserStateSchema = z.object({
-	userId: z.string().nonempty(),
-	isBanned: z.boolean(),
-	bannedAt: z.iso.datetime().nullable(),
-	bannedUntil: z.iso.datetime().nullable(),
-	bannedReason: z.string().nullable(),
-	bannedByUserId: z.string().nullable(),
-	createdAt: z.iso.datetime(),
-	updatedAt: z.iso.datetime()
-});
-const adminSessionStateSchema = z.object({
-	sessionId: z.string().nonempty(),
-	revokedAt: z.iso.datetime().nullable(),
-	revokedReason: z.string().nullable(),
-	revokedByUserId: z.string().nullable(),
-	impersonatorUserId: z.string().nullable(),
-	impersonationReason: z.string().nullable(),
-	impersonationExpiresAt: z.iso.datetime().nullable(),
-	createdAt: z.iso.datetime(),
-	updatedAt: z.iso.datetime()
-});
-const adminUserSessionSchema = z.object({
-	session: sessionSchema,
-	state: adminSessionStateSchema.nullable()
-});
-const impersonationSchema = z.object({
-	id: z.string().nonempty(),
-	actorUserId: z.string().nonempty(),
-	targetUserId: z.string().nonempty(),
-	actorSessionId: z.string().nullable(),
-	impersonationSessionId: z.string().nullable(),
-	reason: z.string().nonempty(),
-	startedAt: z.iso.datetime(),
-	expiresAt: z.iso.datetime(),
-	endedAt: z.iso.datetime().nullable(),
-	endedByUserId: z.string().nullable(),
-	createdAt: z.iso.datetime(),
-	updatedAt: z.iso.datetime()
+//#region src/gen/endpoints/api-keys/api-keys.ts
+var api_keys_exports = /* @__PURE__ */ __exportAll({
+	createApiKey: () => createApiKey,
+	deleteApiKey: () => deleteApiKey,
+	getApiKey: () => getApiKey,
+	getCreateApiKeyMutationOptions: () => getCreateApiKeyMutationOptions,
+	getCreateApiKeyUrl: () => getCreateApiKeyUrl,
+	getDeleteApiKeyMutationOptions: () => getDeleteApiKeyMutationOptions,
+	getDeleteApiKeyUrl: () => getDeleteApiKeyUrl,
+	getGetApiKeyQueryKey: () => getGetApiKeyQueryKey,
+	getGetApiKeyQueryOptions: () => getGetApiKeyQueryOptions,
+	getGetApiKeyUrl: () => getGetApiKeyUrl,
+	getListApiKeysQueryKey: () => getListApiKeysQueryKey,
+	getListApiKeysQueryOptions: () => getListApiKeysQueryOptions,
+	getListApiKeysUrl: () => getListApiKeysUrl,
+	getUpdateApiKeyMutationOptions: () => getUpdateApiKeyMutationOptions,
+	getUpdateApiKeyUrl: () => getUpdateApiKeyUrl,
+	getVerifyApiKeyMutationOptions: () => getVerifyApiKeyMutationOptions,
+	getVerifyApiKeyUrl: () => getVerifyApiKeyUrl,
+	listApiKeys: () => listApiKeys,
+	updateApiKey: () => updateApiKey,
+	useCreateApiKey: () => useCreateApiKey,
+	useDeleteApiKey: () => useDeleteApiKey,
+	useGetApiKey: () => useGetApiKey,
+	useListApiKeys: () => useListApiKeys,
+	useUpdateApiKey: () => useUpdateApiKey,
+	useVerifyApiKey: () => useVerifyApiKey,
+	verifyApiKey: () => verifyApiKey
 });
+const withQueryKey$7 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getListApiKeysUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/api-keys?${stringifiedParams}` : `/api-keys`;
+};
+/**
+* Lists API keys with pagination, optionally filtered by owner.
+* @summary List API keys
+*/
+const listApiKeys = async (params, options) => {
+	return customFetch(getListApiKeysUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getListApiKeysQueryKey = (params) => {
+	return [`/api-keys`, ...params ? [params] : []];
+};
+const getListApiKeysQueryOptions = (params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListApiKeysQueryKey(params);
+	const queryFn = ({ signal }) => listApiKeys(params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List API keys
+*/
+function useListApiKeys(params, options, queryClient) {
+	const queryOptions = getListApiKeysQueryOptions(params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$7(query, queryOptions.queryKey);
+}
+const getCreateApiKeyUrl = () => {
+	return `/api-keys`;
+};
+/**
+* Creates a new API key for the specified owner.
+* @summary Create API key
+*/
+const createApiKey = async (createApiKeyRequest, options) => {
+	return customFetch(getCreateApiKeyUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createApiKeyRequest)
+	});
+};
+const getCreateApiKeyMutationOptions = (options) => {
+	const mutationKey = ["createApiKey"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return createApiKey(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Create API key
+*/
+const useCreateApiKey = (options, queryClient) => {
+	return useMutation(getCreateApiKeyMutationOptions(options), queryClient);
+};
+const getVerifyApiKeyUrl = () => {
+	return `/api-keys/verify`;
+};
+/**
+* Verifies an API key by its raw value and returns the associated key details.
+* @summary Verify API key
+*/
+const verifyApiKey = async (verifyApiKeyRequest, options) => {
+	return customFetch(getVerifyApiKeyUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(verifyApiKeyRequest)
+	});
+};
+const getVerifyApiKeyMutationOptions = (options) => {
+	const mutationKey = ["verifyApiKey"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return verifyApiKey(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Verify API key
+*/
+const useVerifyApiKey = (options, queryClient) => {
+	return useMutation(getVerifyApiKeyMutationOptions(options), queryClient);
+};
+const getGetApiKeyUrl = (id) => {
+	return `/api-keys/${id}`;
+};
+/**
+* Retrieves an API key by its ID.
+* @summary Get API key by ID
+*/
+const getApiKey = async (id, options) => {
+	return customFetch(getGetApiKeyUrl(id), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetApiKeyQueryKey = (id) => {
+	return [`/api-keys/${id}`];
+};
+const getGetApiKeyQueryOptions = (id, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetApiKeyQueryKey(id);
+	const queryFn = ({ signal }) => getApiKey(id, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: id !== null && id !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get API key by ID
+*/
+function useGetApiKey(id, options, queryClient) {
+	const queryOptions = getGetApiKeyQueryOptions(id, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$7(query, queryOptions.queryKey);
+}
+const getDeleteApiKeyUrl = (id) => {
+	return `/api-keys/${id}`;
+};
+/**
+* Deletes an API key.
+* @summary Delete API key
+*/
+const deleteApiKey = async (id, options) => {
+	return customFetch(getDeleteApiKeyUrl(id), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getDeleteApiKeyMutationOptions = (options) => {
+	const mutationKey = ["deleteApiKey"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { id } = props ?? {};
+		return deleteApiKey(id, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Delete API key
+*/
+const useDeleteApiKey = (options, queryClient) => {
+	return useMutation(getDeleteApiKeyMutationOptions(options), queryClient);
+};
+const getUpdateApiKeyUrl = (id) => {
+	return `/api-keys/${id}`;
+};
+/**
+* Updates an API key's attributes.
+* @summary Update API key
+*/
+const updateApiKey = async (id, updateApiKeyRequest, options) => {
+	return customFetch(getUpdateApiKeyUrl(id), {
+		...options,
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(updateApiKeyRequest)
+	});
+};
+const getUpdateApiKeyMutationOptions = (options) => {
+	const mutationKey = ["updateApiKey"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { id, data } = props ?? {};
+		return updateApiKey(id, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Update API key
+*/
+const useUpdateApiKey = (options, queryClient) => {
+	return useMutation(getUpdateApiKeyMutationOptions(options), queryClient);
+};
+
+//#endregion
+//#region src/plugins/api-key/plugin.ts
+var ApiKeyPlugin = class {
+	id = "apiKey";
+	constructor() {}
+	init(client) {
+		return wrapGenerated(api_keys_exports, client);
+	}
+};
 
 //#endregion
 //#region src/plugins/bearer/plugin.ts
@@ -375,6 +2772,124 @@ var BearerPlugin = class {
 	}
 };
 
+//#endregion
+//#region src/gen/endpoints/core/core.ts
+var core_exports = /* @__PURE__ */ __exportAll({
+	getGetMeQueryKey: () => getGetMeQueryKey,
+	getGetMeQueryOptions: () => getGetMeQueryOptions,
+	getGetMeUrl: () => getGetMeUrl,
+	getMe: () => getMe,
+	getSignOutMutationOptions: () => getSignOutMutationOptions,
+	getSignOutUrl: () => getSignOutUrl,
+	signOut: () => signOut,
+	useGetMe: () => useGetMe,
+	useSignOut: () => useSignOut
+});
+const withQueryKey$6 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getGetMeUrl = () => {
+	return `/me`;
+};
+/**
+* Retrieves the authenticated user's profile and current session.
+* @summary Get current user
+*/
+const getMe = async (options) => {
+	return customFetch(getGetMeUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetMeQueryKey = () => {
+	return [`/me`];
+};
+const getGetMeQueryOptions = (options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetMeQueryKey();
+	const queryFn = ({ signal }) => getMe({
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary Get current user
+*/
+function useGetMe(options, queryClient) {
+	const queryOptions = getGetMeQueryOptions(options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$6(query, queryOptions.queryKey);
+}
+const getSignOutUrl = () => {
+	return `/sign-out`;
+};
+/**
+* Signs out the authenticated user. Optionally sign out a specific session or all sessions.
+* @summary Sign out
+*/
+const signOut = async (signOutRequest, options) => {
+	return customFetch(getSignOutUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(signOutRequest)
+	});
+};
+const getSignOutMutationOptions = (options) => {
+	const mutationKey = ["signOut"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return signOut(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Sign out
+*/
+const useSignOut = (options, queryClient) => {
+	return useMutation(getSignOutMutationOptions(options), queryClient);
+};
+
+//#endregion
+//#region src/plugins/core/plugin.ts
+var CorePlugin = class {
+	id = "core";
+	constructor() {}
+	init(client) {
+		return wrapGenerated(core_exports, client);
+	}
+};
+
 //#endregion
 //#region src/plugins/csrf/plugin.ts
 var CSRFPlugin = class {
@@ -385,290 +2900,1342 @@ var CSRFPlugin = class {
 	}
 	init(client) {
 		client.registerBeforeFetch(async (ctx) => {
-			if (typeof document !== "undefined") {
-				if ([
-					"OPTIONS",
-					"HEAD",
-					"GET"
-				].includes(ctx.init.method || "GET")) return;
-				const value = parseCookie(document.cookie)[this.options.cookieName];
-				if (!value) return;
-				ctx.init.headers = new Headers(ctx.init.headers);
-				ctx.init.headers.set(this.options.headerName, value);
-				return;
-			}
-			if (this.cookies) {
-				if ([
-					"OPTIONS",
-					"HEAD",
-					"GET"
-				].includes(ctx.init.method || "GET")) return;
-				const cookie = (await this.cookies()).get(this.options.cookieName);
-				if (!cookie) return;
-				ctx.init.headers = new Headers(ctx.init.headers);
-				ctx.init.headers.set(this.options.headerName, cookie.value);
-			}
+			if ([
+				"OPTIONS",
+				"HEAD",
+				"GET"
+			].includes(ctx.init.method || "GET")) return;
+			const value = ctx.cookies?.[this.options.cookieName] ?? await client.getCookie(this.options.cookieName);
+			if (!value) return;
+			ctx.init.headers = new Headers(ctx.init.headers);
+			ctx.init.headers.set(this.options.headerName, value);
 		});
 		return {};
 	}
-	cookies;
-	attachCookies(fn) {
-		this.cookies = fn;
+};
+
+//#endregion
+//#region src/gen/endpoints/email-password-plugin/email-password-plugin.ts
+var email_password_plugin_exports = /* @__PURE__ */ __exportAll({
+	changePassword: () => changePassword,
+	getChangePasswordMutationOptions: () => getChangePasswordMutationOptions,
+	getChangePasswordUrl: () => getChangePasswordUrl,
+	getRequestEmailChangeMutationOptions: () => getRequestEmailChangeMutationOptions,
+	getRequestEmailChangeUrl: () => getRequestEmailChangeUrl,
+	getRequestPasswordResetMutationOptions: () => getRequestPasswordResetMutationOptions,
+	getRequestPasswordResetUrl: () => getRequestPasswordResetUrl,
+	getSendEmailVerificationMutationOptions: () => getSendEmailVerificationMutationOptions,
+	getSendEmailVerificationUrl: () => getSendEmailVerificationUrl,
+	getSignInMutationOptions: () => getSignInMutationOptions,
+	getSignInUrl: () => getSignInUrl,
+	getSignUpMutationOptions: () => getSignUpMutationOptions,
+	getSignUpUrl: () => getSignUpUrl,
+	getVerifyEmailQueryKey: () => getVerifyEmailQueryKey,
+	getVerifyEmailQueryOptions: () => getVerifyEmailQueryOptions,
+	getVerifyEmailUrl: () => getVerifyEmailUrl,
+	requestEmailChange: () => requestEmailChange,
+	requestPasswordReset: () => requestPasswordReset,
+	sendEmailVerification: () => sendEmailVerification,
+	signIn: () => signIn,
+	signUp: () => signUp,
+	useChangePassword: () => useChangePassword,
+	useRequestEmailChange: () => useRequestEmailChange,
+	useRequestPasswordReset: () => useRequestPasswordReset,
+	useSendEmailVerification: () => useSendEmailVerification,
+	useSignIn: () => useSignIn,
+	useSignUp: () => useSignUp,
+	useVerifyEmail: () => useVerifyEmail,
+	verifyEmail: () => verifyEmail
+});
+const withQueryKey$5 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
 	}
+	return result;
+};
+const getChangePasswordUrl = () => {
+	return `/email-password/change-password`;
+};
+/**
+* Changes the user's password using a reset token
+* @summary Change password
+*/
+const changePassword = async (changePasswordRequest, options) => {
+	return customFetch(getChangePasswordUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(changePasswordRequest)
+	});
+};
+const getChangePasswordMutationOptions = (options) => {
+	const mutationKey = ["changePassword"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return changePassword(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Change password
+*/
+const useChangePassword = (options, queryClient) => {
+	return useMutation(getChangePasswordMutationOptions(options), queryClient);
+};
+const getRequestEmailChangeUrl = () => {
+	return `/email-password/request-email-change`;
+};
+/**
+* Requests to change the authenticated user's email address
+* @summary Request email change
+*/
+const requestEmailChange = async (requestEmailChangeRequest, options) => {
+	return customFetch(getRequestEmailChangeUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(requestEmailChangeRequest)
+	});
 };
+const getRequestEmailChangeMutationOptions = (options) => {
+	const mutationKey = ["requestEmailChange"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return requestEmailChange(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Request email change
+*/
+const useRequestEmailChange = (options, queryClient) => {
+	return useMutation(getRequestEmailChangeMutationOptions(options), queryClient);
+};
+const getRequestPasswordResetUrl = () => {
+	return `/email-password/request-password-reset`;
+};
+/**
+* Requests a password reset link to be sent to the user's email
+* @summary Request password reset
+*/
+const requestPasswordReset = async (requestPasswordResetRequest, options) => {
+	return customFetch(getRequestPasswordResetUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(requestPasswordResetRequest)
+	});
+};
+const getRequestPasswordResetMutationOptions = (options) => {
+	const mutationKey = ["requestPasswordReset"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return requestPasswordReset(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Request password reset
+*/
+const useRequestPasswordReset = (options, queryClient) => {
+	return useMutation(getRequestPasswordResetMutationOptions(options), queryClient);
+};
+const getSendEmailVerificationUrl = () => {
+	return `/email-password/send-email-verification`;
+};
+/**
+* Sends a verification email to the authenticated user
+* @summary Send email verification
+*/
+const sendEmailVerification = async (sendEmailVerificationRequest, options) => {
+	return customFetch(getSendEmailVerificationUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(sendEmailVerificationRequest)
+	});
+};
+const getSendEmailVerificationMutationOptions = (options) => {
+	const mutationKey = ["sendEmailVerification"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return sendEmailVerification(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Send email verification
+*/
+const useSendEmailVerification = (options, queryClient) => {
+	return useMutation(getSendEmailVerificationMutationOptions(options), queryClient);
+};
+const getSignInUrl = () => {
+	return `/email-password/sign-in`;
+};
+/**
+* Authenticates a user with email and password
+* @summary Sign in
+*/
+const signIn = async (signInRequest, options) => {
+	return customFetch(getSignInUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(signInRequest)
+	});
+};
+const getSignInMutationOptions = (options) => {
+	const mutationKey = ["signIn"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return signIn(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Sign in
+*/
+const useSignIn = (options, queryClient) => {
+	return useMutation(getSignInMutationOptions(options), queryClient);
+};
+const getSignUpUrl = () => {
+	return `/email-password/sign-up`;
+};
+/**
+* Registers a new user with email and password
+* @summary Register new user
+*/
+const signUp = async (signUpRequest, options) => {
+	return customFetch(getSignUpUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(signUpRequest)
+	});
+};
+const getSignUpMutationOptions = (options) => {
+	const mutationKey = ["signUp"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return signUp(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Register new user
+*/
+const useSignUp = (options, queryClient) => {
+	return useMutation(getSignUpMutationOptions(options), queryClient);
+};
+const getVerifyEmailUrl = () => {
+	return `/email-password/verify-email`;
+};
+/**
+* Verifies an email address or processes a password reset token using a verification token
+* @summary Verify email
+*/
+const verifyEmail = async (options) => {
+	return customFetch(getVerifyEmailUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getVerifyEmailQueryKey = () => {
+	return [`/email-password/verify-email`];
+};
+const getVerifyEmailQueryOptions = (options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getVerifyEmailQueryKey();
+	const queryFn = ({ signal }) => verifyEmail({
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary Verify email
+*/
+function useVerifyEmail(options, queryClient) {
+	const queryOptions = getVerifyEmailQueryOptions(options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$5(query, queryOptions.queryKey);
+}
 
 //#endregion
 //#region src/plugins/email-password/plugin.ts
 var EmailPasswordPlugin = class {
 	id = "emailPassword";
 	init(client) {
-		return {
-			signUp: async (data) => {
-				return wrappedFetch(client, "/email-password/sign-up", {
-					method: "POST",
-					body: data
-				});
-			},
-			signIn: async (data) => {
-				return wrappedFetch(client, "/email-password/sign-in", {
-					method: "POST",
-					body: data
-				});
-			},
-			sendEmailVerification: async (data) => {
-				return wrappedFetch(client, `/email-password/send-email-verification`, {
-					method: "POST",
-					body: data
-				});
-			},
-			requestPasswordReset: async (data) => {
-				return wrappedFetch(client, `/email-password/request-password-reset`, {
-					method: "POST",
-					body: data
-				});
-			},
-			changePassword: async (data) => {
-				return wrappedFetch(client, `/email-password/change-password`, {
-					method: "POST",
-					body: data
-				});
-			},
-			requestEmailChange: async (data) => {
-				return wrappedFetch(client, `/email-password/request-email-change`, {
-					method: "POST",
-					body: data
-				});
-			}
-		};
+		return wrapGenerated(email_password_plugin_exports, client);
 	}
 };
 
+//#endregion
+//#region src/gen/endpoints/jwt-plugin/jwt-plugin.ts
+var jwt_plugin_exports = /* @__PURE__ */ __exportAll({
+	getGetJWKSQueryKey: () => getGetJWKSQueryKey,
+	getGetJWKSQueryOptions: () => getGetJWKSQueryOptions,
+	getGetJWKSUrl: () => getGetJWKSUrl,
+	getJWKS: () => getJWKS,
+	getRefreshTokenMutationOptions: () => getRefreshTokenMutationOptions,
+	getRefreshTokenUrl: () => getRefreshTokenUrl,
+	refreshToken: () => refreshToken,
+	useGetJWKS: () => useGetJWKS,
+	useRefreshToken: () => useRefreshToken
+});
+const withQueryKey$4 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getGetJWKSUrl = () => {
+	return `/.well-known/jwks.json`;
+};
+/**
+* Returns the JSON Web Key Set (JWKS) containing the public keys used to verify JWT signatures.
+* @summary Get JWKS
+*/
+const getJWKS = async (options) => {
+	return customFetch(getGetJWKSUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetJWKSQueryKey = () => {
+	return [`/.well-known/jwks.json`];
+};
+const getGetJWKSQueryOptions = (options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetJWKSQueryKey();
+	const queryFn = ({ signal }) => getJWKS({
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary Get JWKS
+*/
+function useGetJWKS(options, queryClient) {
+	const queryOptions = getGetJWKSQueryOptions(options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$4(query, queryOptions.queryKey);
+}
+const getRefreshTokenUrl = () => {
+	return `/token/refresh`;
+};
+/**
+* Exchanges a valid refresh token for a new access token and refresh token pair.
+* @summary Refresh JWT token
+*/
+const refreshToken = async (refreshTokenRequest, options) => {
+	return customFetch(getRefreshTokenUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(refreshTokenRequest)
+	});
+};
+const getRefreshTokenMutationOptions = (options) => {
+	const mutationKey = ["refreshToken"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return refreshToken(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Refresh JWT token
+*/
+const useRefreshToken = (options, queryClient) => {
+	return useMutation(getRefreshTokenMutationOptions(options), queryClient);
+};
+
 //#endregion
 //#region src/plugins/jwt/plugin.ts
 var JWTPlugin = class {
 	id = "jwt";
 	constructor() {}
 	init(client) {
-		return {
-			refreshToken: async (data) => {
-				return wrappedFetch(client, "/token/refresh", {
-					method: "POST",
-					body: data
-				});
-			},
-			getJWKSKeys: async () => {
-				return wrappedFetch(client, "/.well-known/jwks.json", { method: "GET" });
-			}
-		};
+		return wrapGenerated(jwt_plugin_exports, client);
 	}
 };
 
+//#endregion
+//#region src/gen/endpoints/magic-link-plugin/magic-link-plugin.ts
+var magic_link_plugin_exports = /* @__PURE__ */ __exportAll({
+	exchangeMagicLink: () => exchangeMagicLink,
+	getExchangeMagicLinkMutationOptions: () => getExchangeMagicLinkMutationOptions,
+	getExchangeMagicLinkUrl: () => getExchangeMagicLinkUrl,
+	getSignInWithMagicLinkMutationOptions: () => getSignInWithMagicLinkMutationOptions,
+	getSignInWithMagicLinkUrl: () => getSignInWithMagicLinkUrl,
+	getVerifyMagicLinkQueryKey: () => getVerifyMagicLinkQueryKey,
+	getVerifyMagicLinkQueryOptions: () => getVerifyMagicLinkQueryOptions,
+	getVerifyMagicLinkUrl: () => getVerifyMagicLinkUrl,
+	signInWithMagicLink: () => signInWithMagicLink,
+	useExchangeMagicLink: () => useExchangeMagicLink,
+	useSignInWithMagicLink: () => useSignInWithMagicLink,
+	useVerifyMagicLink: () => useVerifyMagicLink,
+	verifyMagicLink: () => verifyMagicLink
+});
+const withQueryKey$3 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getExchangeMagicLinkUrl = () => {
+	return `/magic-link/exchange`;
+};
+/**
+* Exchanges a verified magic link token for an authenticated user session.
+* @summary Exchange magic link token for session
+*/
+const exchangeMagicLink = async (magicLinkExchangeRequest, options) => {
+	return customFetch(getExchangeMagicLinkUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(magicLinkExchangeRequest)
+	});
+};
+const getExchangeMagicLinkMutationOptions = (options) => {
+	const mutationKey = ["exchangeMagicLink"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return exchangeMagicLink(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Exchange magic link token for session
+*/
+const useExchangeMagicLink = (options, queryClient) => {
+	return useMutation(getExchangeMagicLinkMutationOptions(options), queryClient);
+};
+const getSignInWithMagicLinkUrl = () => {
+	return `/magic-link/sign-in`;
+};
+/**
+* Sends a magic link to the given email address if an account exists. Optionally creates a new account if sign-up is enabled.
+* @summary Sign in with magic link
+*/
+const signInWithMagicLink = async (magicLinkSignInRequest, options) => {
+	return customFetch(getSignInWithMagicLinkUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(magicLinkSignInRequest)
+	});
+};
+const getSignInWithMagicLinkMutationOptions = (options) => {
+	const mutationKey = ["signInWithMagicLink"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return signInWithMagicLink(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Sign in with magic link
+*/
+const useSignInWithMagicLink = (options, queryClient) => {
+	return useMutation(getSignInWithMagicLinkMutationOptions(options), queryClient);
+};
+const getVerifyMagicLinkUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/magic-link/verify?${stringifiedParams}` : `/magic-link/verify`;
+};
+/**
+* Verifies a magic link token. If a callback_url is provided and trusted, redirects the user with an exchange token appended. Otherwise returns the exchange token in the JSON response.
+* @summary Verify magic link token
+*/
+const verifyMagicLink = async (params, options) => {
+	return customFetch(getVerifyMagicLinkUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getVerifyMagicLinkQueryKey = (params) => {
+	return [`/magic-link/verify`, ...params ? [params] : []];
+};
+const getVerifyMagicLinkQueryOptions = (params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getVerifyMagicLinkQueryKey(params);
+	const queryFn = ({ signal }) => verifyMagicLink(params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary Verify magic link token
+*/
+function useVerifyMagicLink(params, options, queryClient) {
+	const queryOptions = getVerifyMagicLinkQueryOptions(params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$3(query, queryOptions.queryKey);
+}
+
 //#endregion
 //#region src/plugins/magic-link/plugin.ts
 var MagicLinkPlugin = class {
 	id = "magicLink";
 	constructor() {}
 	init(client) {
-		return {
-			signIn: async (data) => {
-				return wrappedFetch(client, "/magic-link/sign-in", {
-					method: "POST",
-					body: data
-				});
-			},
-			verify: async (data) => {
-				const searchParams = new URLSearchParams();
-				searchParams.append("token", data.token);
-				if (data.callbackUrl) searchParams.append("callback_url", data.callbackUrl);
-				return wrappedFetch(client, `/magic-link/verify?${searchParams.toString()}`, { method: "GET" });
-			},
-			exchange: async (data) => {
-				return wrappedFetch(client, "/magic-link/exchange", {
-					method: "POST",
-					body: data
-				});
-			}
-		};
+		return wrapGenerated(magic_link_plugin_exports, client);
 	}
 };
 
+//#endregion
+//#region src/gen/endpoints/oauth2-plugin/oauth2-plugin.ts
+var oauth2_plugin_exports = /* @__PURE__ */ __exportAll({
+	getOauthAuthorizeQueryKey: () => getOauthAuthorizeQueryKey,
+	getOauthAuthorizeQueryOptions: () => getOauthAuthorizeQueryOptions,
+	getOauthAuthorizeUrl: () => getOauthAuthorizeUrl,
+	getOauthCallbackQueryKey: () => getOauthCallbackQueryKey,
+	getOauthCallbackQueryOptions: () => getOauthCallbackQueryOptions,
+	getOauthCallbackUrl: () => getOauthCallbackUrl,
+	oauthAuthorize: () => oauthAuthorize,
+	oauthCallback: () => oauthCallback,
+	useOauthAuthorize: () => useOauthAuthorize,
+	useOauthCallback: () => useOauthCallback
+});
+const withQueryKey$2 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getOauthAuthorizeUrl = (provider, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/oauth2/authorize/${provider}?${stringifiedParams}` : `/oauth2/authorize/${provider}`;
+};
+/**
+* Initiates the OAuth2 authorization flow with the specified provider. Returns the provider's authorization URL to redirect the user to.
+* @summary Authorize with OAuth2 provider
+*/
+const oauthAuthorize = async (provider, params, options) => {
+	return customFetch(getOauthAuthorizeUrl(provider, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getOauthAuthorizeQueryKey = (provider, params) => {
+	return [`/oauth2/authorize/${provider}`, ...params ? [params] : []];
+};
+const getOauthAuthorizeQueryOptions = (provider, params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getOauthAuthorizeQueryKey(provider, params);
+	const queryFn = ({ signal }) => oauthAuthorize(provider, params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: provider !== null && provider !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Authorize with OAuth2 provider
+*/
+function useOauthAuthorize(provider, params, options, queryClient) {
+	const queryOptions = getOauthAuthorizeQueryOptions(provider, params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$2(query, queryOptions.queryKey);
+}
+const getOauthCallbackUrl = (provider, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/oauth2/callback/${provider}?${stringifiedParams}` : `/oauth2/callback/${provider}`;
+};
+/**
+* Handles the OAuth2 callback from the provider. Exchanges the authorization code for tokens, creates or links a user account, and returns the authenticated user and session.
+* @summary OAuth2 callback
+*/
+const oauthCallback = async (provider, params, options) => {
+	return customFetch(getOauthCallbackUrl(provider, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getOauthCallbackQueryKey = (provider, params) => {
+	return [`/oauth2/callback/${provider}`, ...params ? [params] : []];
+};
+const getOauthCallbackQueryOptions = (provider, params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getOauthCallbackQueryKey(provider, params);
+	const queryFn = ({ signal }) => oauthCallback(provider, params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: provider !== null && provider !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary OAuth2 callback
+*/
+function useOauthCallback(provider, params, options, queryClient) {
+	const queryOptions = getOauthCallbackQueryOptions(provider, params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$2(query, queryOptions.queryKey);
+}
+
 //#endregion
 //#region src/plugins/oauth2/plugin.ts
 var OAuth2Plugin = class {
 	id = "oauth2";
 	init(client) {
-		return { signIn: async (data) => {
-			return wrappedFetch(client, `/oauth2/authorize/${data.provider}?redirect_to=${data.redirectTo}`, { method: "GET" });
-		} };
+		return wrapGenerated(oauth2_plugin_exports, client);
 	}
 };
 
+//#endregion
+//#region src/gen/endpoints/organizations/organizations.ts
+var organizations_exports = /* @__PURE__ */ __exportAll({
+	createOrganization: () => createOrganization,
+	deleteOrganization: () => deleteOrganization,
+	getCreateOrganizationMutationOptions: () => getCreateOrganizationMutationOptions,
+	getCreateOrganizationUrl: () => getCreateOrganizationUrl,
+	getDeleteOrganizationMutationOptions: () => getDeleteOrganizationMutationOptions,
+	getDeleteOrganizationUrl: () => getDeleteOrganizationUrl,
+	getGetOrganizationQueryKey: () => getGetOrganizationQueryKey,
+	getGetOrganizationQueryOptions: () => getGetOrganizationQueryOptions,
+	getGetOrganizationUrl: () => getGetOrganizationUrl,
+	getListOrganizationsQueryKey: () => getListOrganizationsQueryKey,
+	getListOrganizationsQueryOptions: () => getListOrganizationsQueryOptions,
+	getListOrganizationsUrl: () => getListOrganizationsUrl,
+	getOrganization: () => getOrganization,
+	getUpdateOrganizationMutationOptions: () => getUpdateOrganizationMutationOptions,
+	getUpdateOrganizationUrl: () => getUpdateOrganizationUrl,
+	listOrganizations: () => listOrganizations,
+	updateOrganization: () => updateOrganization,
+	useCreateOrganization: () => useCreateOrganization,
+	useDeleteOrganization: () => useDeleteOrganization,
+	useGetOrganization: () => useGetOrganization,
+	useListOrganizations: () => useListOrganizations,
+	useUpdateOrganization: () => useUpdateOrganization
+});
+const withQueryKey$1 = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getListOrganizationsUrl = () => {
+	return `/organizations`;
+};
+/**
+* Lists all organizations owned by the authenticated user.
+* @summary List organizations
+*/
+const listOrganizations = async (options) => {
+	return customFetch(getListOrganizationsUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getListOrganizationsQueryKey = () => {
+	return [`/organizations`];
+};
+const getListOrganizationsQueryOptions = (options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getListOrganizationsQueryKey();
+	const queryFn = ({ signal }) => listOrganizations({
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List organizations
+*/
+function useListOrganizations(options, queryClient) {
+	const queryOptions = getListOrganizationsQueryOptions(options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$1(query, queryOptions.queryKey);
+}
+const getCreateOrganizationUrl = () => {
+	return `/organizations`;
+};
+/**
+* Creates a new organization with the authenticated user as the owner.
+* @summary Create organization
+*/
+const createOrganization = async (createOrganizationRequest, options) => {
+	return customFetch(getCreateOrganizationUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(createOrganizationRequest)
+	});
+};
+const getCreateOrganizationMutationOptions = (options) => {
+	const mutationKey = ["createOrganization"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return createOrganization(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Create organization
+*/
+const useCreateOrganization = (options, queryClient) => {
+	return useMutation(getCreateOrganizationMutationOptions(options), queryClient);
+};
+const getGetOrganizationUrl = (organizationId) => {
+	return `/organizations/${organizationId}`;
+};
+/**
+* Retrieves an organization by its ID.
+* @summary Get organization
+*/
+const getOrganization = async (organizationId, options) => {
+	return customFetch(getGetOrganizationUrl(organizationId), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetOrganizationQueryKey = (organizationId) => {
+	return [`/organizations/${organizationId}`];
+};
+const getGetOrganizationQueryOptions = (organizationId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetOrganizationQueryKey(organizationId);
+	const queryFn = ({ signal }) => getOrganization(organizationId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: organizationId !== null && organizationId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get organization
+*/
+function useGetOrganization(organizationId, options, queryClient) {
+	const queryOptions = getGetOrganizationQueryOptions(organizationId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey$1(query, queryOptions.queryKey);
+}
+const getDeleteOrganizationUrl = (organizationId) => {
+	return `/organizations/${organizationId}`;
+};
+/**
+* Deletes an organization.
+* @summary Delete organization
+*/
+const deleteOrganization = async (organizationId, options) => {
+	return customFetch(getDeleteOrganizationUrl(organizationId), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getDeleteOrganizationMutationOptions = (options) => {
+	const mutationKey = ["deleteOrganization"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { organizationId } = props ?? {};
+		return deleteOrganization(organizationId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Delete organization
+*/
+const useDeleteOrganization = (options, queryClient) => {
+	return useMutation(getDeleteOrganizationMutationOptions(options), queryClient);
+};
+const getUpdateOrganizationUrl = (organizationId) => {
+	return `/organizations/${organizationId}`;
+};
+/**
+* Updates an existing organization.
+* @summary Update organization
+*/
+const updateOrganization = async (organizationId, updateOrganizationRequest, options) => {
+	return customFetch(getUpdateOrganizationUrl(organizationId), {
+		...options,
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(updateOrganizationRequest)
+	});
+};
+const getUpdateOrganizationMutationOptions = (options) => {
+	const mutationKey = ["updateOrganization"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { organizationId, data } = props ?? {};
+		return updateOrganization(organizationId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Update organization
+*/
+const useUpdateOrganization = (options, queryClient) => {
+	return useMutation(getUpdateOrganizationMutationOptions(options), queryClient);
+};
+
 //#endregion
 //#region src/plugins/organizations/plugin.ts
 var OrganizationsPlugin = class {
 	id = "organizations";
 	init(client) {
-		return {
-			createOrganization: async (data) => {
-				return wrappedFetch(client, "/organizations", {
-					method: "POST",
-					body: data
-				});
-			},
-			getAllOrganizations: async () => {
-				return wrappedFetch(client, "/organizations", { method: "GET" });
-			},
-			getOrganizationById: async (organizationId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}`, { method: "GET" });
-			},
-			updateOrganization: async (organizationId, data) => {
-				return wrappedFetch(client, `/organizations/${organizationId}`, {
-					method: "PATCH",
-					body: data
-				});
-			},
-			deleteOrganization: async (organizationId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}`, { method: "DELETE" });
-			},
-			createOrganizationInvitation: async (organizationId, data) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/invitations`, {
-					method: "POST",
-					body: data
-				});
-			},
-			getAllOrganizationInvitations: async (organizationId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/invitations`, { method: "GET" });
-			},
-			getOrganizationInvitation: async (organizationId, invitationId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/invitations/${invitationId}`, { method: "GET" });
-			},
-			revokeOrganizationInvitation: async (organizationId, invitationId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/invitations/${invitationId}`, { method: "PATCH" });
-			},
-			acceptOrganizationInvitation: async (organizationId, invitationId, data) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/invitations/${invitationId}/accept`, {
-					method: "POST",
-					body: data
-				});
-			},
-			rejectOrganizationInvitation: async (organizationId, invitationId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/invitations/${invitationId}/reject`, { method: "POST" });
-			},
-			addOrganizationMember: async (organizationId, data) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/members`, {
-					method: "POST",
-					body: data
-				});
-			},
-			getAllOrganizationMembers: async (organizationId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/members`, { method: "GET" });
-			},
-			getOrganizationMember: async (organizationId, memberId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/members/${memberId}`, { method: "GET" });
-			},
-			updateOrganizationMember: async (organizationId, memberId, data) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/members/${memberId}`, {
-					method: "PATCH",
-					body: data
-				});
-			},
-			deleteOrganizationMember: async (organizationId, memberId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/members/${memberId}`, { method: "DELETE" });
-			},
-			createOrganizationTeam: async (organizationId, data) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/teams`, {
-					method: "POST",
-					body: data
-				});
-			},
-			getAllOrganizationTeams: async (organizationId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/teams`, { method: "GET" });
-			},
-			getOrganizationTeam: async (organizationId, teamId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/teams/${teamId}`, { method: "GET" });
-			},
-			updateOrganizationTeam: async (organizationId, teamId, data) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/teams/${teamId}`, {
-					method: "PATCH",
-					body: data
-				});
-			},
-			deleteOrganizationTeam: async (organizationId, teamId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/teams/${teamId}`, { method: "DELETE" });
-			},
-			addOrganizationTeamMember: async (organizationId, teamId, data) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/teams/${teamId}/members`, {
-					method: "POST",
-					body: data
-				});
-			},
-			getAllOrganizationTeamMembers: async (organizationId, teamId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/teams/${teamId}/members`, { method: "GET" });
-			},
-			getOrganizationTeamMember: async (organizationId, teamId, memberId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/teams/${teamId}/members/${memberId}`, { method: "GET" });
-			},
-			deleteOrganizationTeamMember: async (organizationId, teamId, memberId) => {
-				return wrappedFetch(client, `/organizations/${organizationId}/teams/${teamId}/members/${memberId}`, { method: "DELETE" });
-			}
-		};
+		return wrapGenerated(organizations_exports, client);
 	}
 };
 
+//#endregion
+//#region src/gen/endpoints/totp-plugin/totp-plugin.ts
+var totp_plugin_exports = /* @__PURE__ */ __exportAll({
+	disableTotp: () => disableTotp,
+	enableTotp: () => enableTotp,
+	generateTotpBackupCodes: () => generateTotpBackupCodes,
+	getDisableTotpMutationOptions: () => getDisableTotpMutationOptions,
+	getDisableTotpUrl: () => getDisableTotpUrl,
+	getEnableTotpMutationOptions: () => getEnableTotpMutationOptions,
+	getEnableTotpUrl: () => getEnableTotpUrl,
+	getGenerateTotpBackupCodesMutationOptions: () => getGenerateTotpBackupCodesMutationOptions,
+	getGenerateTotpBackupCodesUrl: () => getGenerateTotpBackupCodesUrl,
+	getGetTotpURIQueryKey: () => getGetTotpURIQueryKey,
+	getGetTotpURIQueryOptions: () => getGetTotpURIQueryOptions,
+	getGetTotpURIUrl: () => getGetTotpURIUrl,
+	getTotpURI: () => getTotpURI,
+	getVerifyTotpBackupCodeMutationOptions: () => getVerifyTotpBackupCodeMutationOptions,
+	getVerifyTotpBackupCodeUrl: () => getVerifyTotpBackupCodeUrl,
+	getVerifyTotpMutationOptions: () => getVerifyTotpMutationOptions,
+	getVerifyTotpUrl: () => getVerifyTotpUrl,
+	useDisableTotp: () => useDisableTotp,
+	useEnableTotp: () => useEnableTotp,
+	useGenerateTotpBackupCodes: () => useGenerateTotpBackupCodes,
+	useGetTotpURI: () => useGetTotpURI,
+	useVerifyTotp: () => useVerifyTotp,
+	useVerifyTotpBackupCode: () => useVerifyTotpBackupCode,
+	verifyTotp: () => verifyTotp,
+	verifyTotpBackupCode: () => verifyTotpBackupCode
+});
+const withQueryKey = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getDisableTotpUrl = () => {
+	return `/totp/disable`;
+};
+/**
+* Disables TOTP two-factor authentication for the authenticated user.
+* @summary Disable TOTP
+*/
+const disableTotp = async (options) => {
+	return customFetch(getDisableTotpUrl(), {
+		...options,
+		method: "POST"
+	});
+};
+const getDisableTotpMutationOptions = (options) => {
+	const mutationKey = ["disableTotp"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = () => {
+		return disableTotp(requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Disable TOTP
+*/
+const useDisableTotp = (options, queryClient) => {
+	return useMutation(getDisableTotpMutationOptions(options), queryClient);
+};
+const getEnableTotpUrl = () => {
+	return `/totp/enable`;
+};
+/**
+* Enables TOTP two-factor authentication for the authenticated user. Returns the TOTP URI and backup codes.
+* @summary Enable TOTP
+*/
+const enableTotp = async (options) => {
+	return customFetch(getEnableTotpUrl(), {
+		...options,
+		method: "POST"
+	});
+};
+const getEnableTotpMutationOptions = (options) => {
+	const mutationKey = ["enableTotp"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = () => {
+		return enableTotp(requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Enable TOTP
+*/
+const useEnableTotp = (options, queryClient) => {
+	return useMutation(getEnableTotpMutationOptions(options), queryClient);
+};
+const getGenerateTotpBackupCodesUrl = () => {
+	return `/totp/generate-backup-codes`;
+};
+/**
+* Generates a new set of backup codes for the authenticated user. Previous backup codes are invalidated.
+* @summary Generate backup codes
+*/
+const generateTotpBackupCodes = async (options) => {
+	return customFetch(getGenerateTotpBackupCodesUrl(), {
+		...options,
+		method: "POST"
+	});
+};
+const getGenerateTotpBackupCodesMutationOptions = (options) => {
+	const mutationKey = ["generateTotpBackupCodes"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = () => {
+		return generateTotpBackupCodes(requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Generate backup codes
+*/
+const useGenerateTotpBackupCodes = (options, queryClient) => {
+	return useMutation(getGenerateTotpBackupCodesMutationOptions(options), queryClient);
+};
+const getGetTotpURIUrl = () => {
+	return `/totp/get-uri`;
+};
+/**
+* Returns the current TOTP URI for the authenticated user's authenticator app configuration.
+* @summary Get TOTP URI
+*/
+const getTotpURI = async (options) => {
+	return customFetch(getGetTotpURIUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getGetTotpURIQueryKey = () => {
+	return [`/totp/get-uri`];
+};
+const getGetTotpURIQueryOptions = (options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getGetTotpURIQueryKey();
+	const queryFn = ({ signal }) => getTotpURI({
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary Get TOTP URI
+*/
+function useGetTotpURI(options, queryClient) {
+	const queryOptions = getGetTotpURIQueryOptions(options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getVerifyTotpUrl = () => {
+	return `/totp/verify`;
+};
+/**
+* Verifies a TOTP code from the authenticator app and completes authentication. Requires a pending TOTP cookie set during sign-in.
+* @summary Verify TOTP code
+*/
+const verifyTotp = async (verifyTOTPRequest, options) => {
+	return customFetch(getVerifyTotpUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(verifyTOTPRequest)
+	});
+};
+const getVerifyTotpMutationOptions = (options) => {
+	const mutationKey = ["verifyTotp"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return verifyTotp(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Verify TOTP code
+*/
+const useVerifyTotp = (options, queryClient) => {
+	return useMutation(getVerifyTotpMutationOptions(options), queryClient);
+};
+const getVerifyTotpBackupCodeUrl = () => {
+	return `/totp/verify-backup-code`;
+};
+/**
+* Verifies a backup code as an alternative to TOTP verification. Completes authentication if the code is valid.
+* @summary Verify backup code
+*/
+const verifyTotpBackupCode = async (verifyBackupCodeRequest, options) => {
+	return customFetch(getVerifyTotpBackupCodeUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...options?.headers
+		},
+		body: JSON.stringify(verifyBackupCodeRequest)
+	});
+};
+const getVerifyTotpBackupCodeMutationOptions = (options) => {
+	const mutationKey = ["verifyTotpBackupCode"];
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return verifyTotpBackupCode(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Verify backup code
+*/
+const useVerifyTotpBackupCode = (options, queryClient) => {
+	return useMutation(getVerifyTotpBackupCodeMutationOptions(options), queryClient);
+};
+
 //#endregion
 //#region src/plugins/totp/plugin.ts
 var TOTPPlugin = class {
 	id = "totp";
 	init(client) {
-		return {
-			enable: async () => {
-				return wrappedFetch(client, "/totp/enable", { method: "POST" });
-			},
-			disable: async () => {
-				return wrappedFetch(client, "/totp/disable", { method: "POST" });
-			},
-			getUri: async () => {
-				return wrappedFetch(client, "/totp/get-uri", { method: "GET" });
-			},
-			verify: async (data) => {
-				return wrappedFetch(client, "/totp/verify", {
-					method: "POST",
-					body: data
-				});
-			},
-			verifyBackupCode: async (data) => {
-				return wrappedFetch(client, "/totp/verify-backup-code", {
-					method: "POST",
-					body: data
-				});
-			},
-			generateBackupCodes: async () => {
-				return wrappedFetch(client, "/totp/generate-backup-codes", { method: "POST" });
-			}
-		};
+		return wrapGenerated(totp_plugin_exports, client);
 	}
 };
 
 //#endregion
-export { AccessControlPlugin, AdminPlugin, BearerPlugin, CSRFPlugin, EmailPasswordPlugin, JWTPlugin, MagicLinkPlugin, OAuth2Plugin, OrganizationsPlugin, TOTPPlugin, adminSessionStateSchema, adminUserSessionSchema, adminUserStateSchema, checkUserPermissionsResponseSchema, getUserPermissionsResponseSchema, impersonationSchema, permissionGrantSourceSchema, permissionSchema, roleDetailsSchema, roleSchema, userPermissionInfoSchema, userRoleInfoSchema };
+export { AccessControlPlugin, AdminPlugin, ApiKeyPlugin, BearerPlugin, CSRFPlugin, CorePlugin, EmailPasswordPlugin, JWTPlugin, MagicLinkPlugin, OAuth2Plugin, OrganizationsPlugin, TOTPPlugin };
 //# sourceMappingURL=index.js.map