lib/api-client-react/src/generated/api.ts - main - Nacauter/SLG

lib/api-client-react/src/generated/api.ts
1 108 строк29 KB
Nacauter
Initial commit SLG
01 апр 2026, 20:29
01 апр 2026, 20:2913e7ba1
/**
 * Generated by orval v8.5.3 🍺
 * Do not edit manually.
 * Api
 * Blind Escape Game Server API
 * OpenAPI spec version: 0.1.0
 */
import { useMutation, useQuery } from "@tanstack/react-query";
import type {
  MutationFunction,
  QueryFunction,
  QueryKey,
  UseMutationOptions,
  UseMutationResult,
  UseQueryOptions,
  UseQueryResult,
} from "@tanstack/react-query";

import type {
  AchievementsData,
  CreateRoomRequest,
  ErrorResponse,
  HealthStatus,
  JoinRoomRequest,
  LeaderboardEntry,
  LeaveRoomRequest,
  PlayerStats,
  ReadyRequest,
  Room,
  ScoreResult,
  ServerStatus,
  StartGameRequest,
  SubmitScoreRequest,
  SuccessResponse,
} from "./api.schemas";

import { customFetch } from "../custom-fetch";
import type { ErrorType, BodyType } from "../custom-fetch";

type AwaitedInput<T> = PromiseLike<T> | T;

type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;

type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];

/**
 * @summary Health check
 */
export const getHealthCheckUrl = () => {
  return `/api/healthz`;
};

export const healthCheck = async (
  options?: RequestInit,
): Promise<HealthStatus> => {
  return customFetch<HealthStatus>(getHealthCheckUrl(), {
    ...options,
    method: "GET",
  });
};

export const getHealthCheckQueryKey = () => {
  return [`/api/healthz`] as const;
};

export const getHealthCheckQueryOptions = <
  TData = Awaited<ReturnType<typeof healthCheck>>,
  TError = ErrorType<unknown>,
>(options?: {
  query?: UseQueryOptions<
    Awaited<ReturnType<typeof healthCheck>>,
    TError,
    TData
  >;
  request?: SecondParameter<typeof customFetch>;
}) => {
  const { query: queryOptions, request: requestOptions } = options ?? {};

  const queryKey = queryOptions?.queryKey ?? getHealthCheckQueryKey();

  const queryFn: QueryFunction<Awaited<ReturnType<typeof healthCheck>>> = ({
    signal,
  }) => healthCheck({ signal, ...requestOptions });

  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
    Awaited<ReturnType<typeof healthCheck>>,
    TError,
    TData
  > & { queryKey: QueryKey };
};

export type HealthCheckQueryResult = NonNullable<
  Awaited<ReturnType<typeof healthCheck>>
>;
export type HealthCheckQueryError = ErrorType<unknown>;

/**
 * @summary Health check
 */

export function useHealthCheck<
  TData = Awaited<ReturnType<typeof healthCheck>>,
  TError = ErrorType<unknown>,
>(options?: {
  query?: UseQueryOptions<
    Awaited<ReturnType<typeof healthCheck>>,
    TError,
    TData
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
  const queryOptions = getHealthCheckQueryOptions(options);

  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
  };

  return { ...query, queryKey: queryOptions.queryKey };
}

/**
 * @summary Get server status and player counts
 */
export const getGetServerStatusUrl = () => {
  return `/api/server/status`;
};

export const getServerStatus = async (
  options?: RequestInit,
): Promise<ServerStatus> => {
  return customFetch<ServerStatus>(getGetServerStatusUrl(), {
    ...options,
    method: "GET",
  });
};

export const getGetServerStatusQueryKey = () => {
  return [`/api/server/status`] as const;
};

export const getGetServerStatusQueryOptions = <
  TData = Awaited<ReturnType<typeof getServerStatus>>,
  TError = ErrorType<unknown>,
>(options?: {
  query?: UseQueryOptions<
    Awaited<ReturnType<typeof getServerStatus>>,
    TError,
    TData
  >;
  request?: SecondParameter<typeof customFetch>;
}) => {
  const { query: queryOptions, request: requestOptions } = options ?? {};

  const queryKey = queryOptions?.queryKey ?? getGetServerStatusQueryKey();

  const queryFn: QueryFunction<Awaited<ReturnType<typeof getServerStatus>>> = ({
    signal,
  }) => getServerStatus({ signal, ...requestOptions });

  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
    Awaited<ReturnType<typeof getServerStatus>>,
    TError,
    TData
  > & { queryKey: QueryKey };
};

export type GetServerStatusQueryResult = NonNullable<
  Awaited<ReturnType<typeof getServerStatus>>
>;
export type GetServerStatusQueryError = ErrorType<unknown>;

/**
 * @summary Get server status and player counts
 */

export function useGetServerStatus<
  TData = Awaited<ReturnType<typeof getServerStatus>>,
  TError = ErrorType<unknown>,
>(options?: {
  query?: UseQueryOptions<
    Awaited<ReturnType<typeof getServerStatus>>,
    TError,
    TData
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
  const queryOptions = getGetServerStatusQueryOptions(options);

  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
  };

  return { ...query, queryKey: queryOptions.queryKey };
}

/**
 * @summary List all active rooms
 */
export const getListRoomsUrl = () => {
  return `/api/rooms`;
};

export const listRooms = async (options?: RequestInit): Promise<Room[]> => {
  return customFetch<Room[]>(getListRoomsUrl(), {
    ...options,
    method: "GET",
  });
};

export const getListRoomsQueryKey = () => {
  return [`/api/rooms`] as const;
};

export const getListRoomsQueryOptions = <
  TData = Awaited<ReturnType<typeof listRooms>>,
  TError = ErrorType<unknown>,
>(options?: {
  query?: UseQueryOptions<Awaited<ReturnType<typeof listRooms>>, TError, TData>;
  request?: SecondParameter<typeof customFetch>;
}) => {
  const { query: queryOptions, request: requestOptions } = options ?? {};

  const queryKey = queryOptions?.queryKey ?? getListRoomsQueryKey();

  const queryFn: QueryFunction<Awaited<ReturnType<typeof listRooms>>> = ({
    signal,
  }) => listRooms({ signal, ...requestOptions });

  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
    Awaited<ReturnType<typeof listRooms>>,
    TError,
    TData
  > & { queryKey: QueryKey };
};

export type ListRoomsQueryResult = NonNullable<
  Awaited<ReturnType<typeof listRooms>>
>;
export type ListRoomsQueryError = ErrorType<unknown>;

/**
 * @summary List all active rooms
 */

export function useListRooms<
  TData = Awaited<ReturnType<typeof listRooms>>,
  TError = ErrorType<unknown>,
>(options?: {
  query?: UseQueryOptions<Awaited<ReturnType<typeof listRooms>>, TError, TData>;
  request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
  const queryOptions = getListRoomsQueryOptions(options);

  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
  };

  return { ...query, queryKey: queryOptions.queryKey };
}

/**
 * @summary Create a new room
 */
export const getCreateRoomUrl = () => {
  return `/api/rooms`;
};

export const createRoom = async (
  createRoomRequest: CreateRoomRequest,
  options?: RequestInit,
): Promise<Room> => {
  return customFetch<Room>(getCreateRoomUrl(), {
    ...options,
    method: "POST",
    headers: { "Content-Type": "application/json", ...options?.headers },
    body: JSON.stringify(createRoomRequest),
  });
};

export const getCreateRoomMutationOptions = <
  TError = ErrorType<ErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof createRoom>>,
    TError,
    { data: BodyType<CreateRoomRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof createRoom>>,
  TError,
  { data: BodyType<CreateRoomRequest> },
  TContext
> => {
  const mutationKey = ["createRoom"];
  const { mutation: mutationOptions, request: requestOptions } = options
    ? options.mutation &&
      "mutationKey" in options.mutation &&
      options.mutation.mutationKey
      ? options
      : { ...options, mutation: { ...options.mutation, mutationKey } }
    : { mutation: { mutationKey }, request: undefined };

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof createRoom>>,
    { data: BodyType<CreateRoomRequest> }
  > = (props) => {
    const { data } = props ?? {};

    return createRoom(data, requestOptions);
  };

  return { mutationFn, ...mutationOptions };
};

export type CreateRoomMutationResult = NonNullable<
  Awaited<ReturnType<typeof createRoom>>
>;
export type CreateRoomMutationBody = BodyType<CreateRoomRequest>;
export type CreateRoomMutationError = ErrorType<ErrorResponse>;

/**
 * @summary Create a new room
 */
export const useCreateRoom = <
  TError = ErrorType<ErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof createRoom>>,
    TError,
    { data: BodyType<CreateRoomRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationResult<
  Awaited<ReturnType<typeof createRoom>>,
  TError,
  { data: BodyType<CreateRoomRequest> },
  TContext
> => {
  return useMutation(getCreateRoomMutationOptions(options));
};

/**
 * @summary Get room details
 */
export const getGetRoomUrl = (roomId: string) => {
  return `/api/rooms/${roomId}`;
};

export const getRoom = async (
  roomId: string,
  options?: RequestInit,
): Promise<Room> => {
  return customFetch<Room>(getGetRoomUrl(roomId), {
    ...options,
    method: "GET",
  });
};

export const getGetRoomQueryKey = (roomId: string) => {
  return [`/api/rooms/${roomId}`] as const;
};

export const getGetRoomQueryOptions = <
  TData = Awaited<ReturnType<typeof getRoom>>,
  TError = ErrorType<ErrorResponse>,
>(
  roomId: string,
  options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getRoom>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
  },
) => {
  const { query: queryOptions, request: requestOptions } = options ?? {};

  const queryKey = queryOptions?.queryKey ?? getGetRoomQueryKey(roomId);

  const queryFn: QueryFunction<Awaited<ReturnType<typeof getRoom>>> = ({
    signal,
  }) => getRoom(roomId, { signal, ...requestOptions });

  return {
    queryKey,
    queryFn,
    enabled: !!roomId,
    ...queryOptions,
  } as UseQueryOptions<Awaited<ReturnType<typeof getRoom>>, TError, TData> & {
    queryKey: QueryKey;
  };
};

export type GetRoomQueryResult = NonNullable<
  Awaited<ReturnType<typeof getRoom>>
>;
export type GetRoomQueryError = ErrorType<ErrorResponse>;

/**
 * @summary Get room details
 */

export function useGetRoom<
  TData = Awaited<ReturnType<typeof getRoom>>,
  TError = ErrorType<ErrorResponse>,
>(
  roomId: string,
  options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getRoom>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
  },
): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
  const queryOptions = getGetRoomQueryOptions(roomId, options);

  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
  };

  return { ...query, queryKey: queryOptions.queryKey };
}

/**
 * @summary Join a room
 */
export const getJoinRoomUrl = (roomId: string) => {
  return `/api/rooms/${roomId}/join`;
};

export const joinRoom = async (
  roomId: string,
  joinRoomRequest: JoinRoomRequest,
  options?: RequestInit,
): Promise<Room> => {
  return customFetch<Room>(getJoinRoomUrl(roomId), {
    ...options,
    method: "POST",
    headers: { "Content-Type": "application/json", ...options?.headers },
    body: JSON.stringify(joinRoomRequest),
  });
};

export const getJoinRoomMutationOptions = <
  TError = ErrorType<ErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof joinRoom>>,
    TError,
    { roomId: string; data: BodyType<JoinRoomRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof joinRoom>>,
  TError,
  { roomId: string; data: BodyType<JoinRoomRequest> },
  TContext
> => {
  const mutationKey = ["joinRoom"];
  const { mutation: mutationOptions, request: requestOptions } = options
    ? options.mutation &&
      "mutationKey" in options.mutation &&
      options.mutation.mutationKey
      ? options
      : { ...options, mutation: { ...options.mutation, mutationKey } }
    : { mutation: { mutationKey }, request: undefined };

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof joinRoom>>,
    { roomId: string; data: BodyType<JoinRoomRequest> }
  > = (props) => {
    const { roomId, data } = props ?? {};

    return joinRoom(roomId, data, requestOptions);
  };

  return { mutationFn, ...mutationOptions };
};

export type JoinRoomMutationResult = NonNullable<
  Awaited<ReturnType<typeof joinRoom>>
>;
export type JoinRoomMutationBody = BodyType<JoinRoomRequest>;
export type JoinRoomMutationError = ErrorType<ErrorResponse>;

/**
 * @summary Join a room
 */
export const useJoinRoom = <
  TError = ErrorType<ErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof joinRoom>>,
    TError,
    { roomId: string; data: BodyType<JoinRoomRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationResult<
  Awaited<ReturnType<typeof joinRoom>>,
  TError,
  { roomId: string; data: BodyType<JoinRoomRequest> },
  TContext
> => {
  return useMutation(getJoinRoomMutationOptions(options));
};

/**
 * @summary Toggle player ready state
 */
export const getSetPlayerReadyUrl = (roomId: string) => {
  return `/api/rooms/${roomId}/ready`;
};

export const setPlayerReady = async (
  roomId: string,
  readyRequest: ReadyRequest,
  options?: RequestInit,
): Promise<Room> => {
  return customFetch<Room>(getSetPlayerReadyUrl(roomId), {
    ...options,
    method: "POST",
    headers: { "Content-Type": "application/json", ...options?.headers },
    body: JSON.stringify(readyRequest),
  });
};

export const getSetPlayerReadyMutationOptions = <
  TError = ErrorType<ErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof setPlayerReady>>,
    TError,
    { roomId: string; data: BodyType<ReadyRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof setPlayerReady>>,
  TError,
  { roomId: string; data: BodyType<ReadyRequest> },
  TContext
> => {
  const mutationKey = ["setPlayerReady"];
  const { mutation: mutationOptions, request: requestOptions } = options
    ? options.mutation &&
      "mutationKey" in options.mutation &&
      options.mutation.mutationKey
      ? options
      : { ...options, mutation: { ...options.mutation, mutationKey } }
    : { mutation: { mutationKey }, request: undefined };

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof setPlayerReady>>,
    { roomId: string; data: BodyType<ReadyRequest> }
  > = (props) => {
    const { roomId, data } = props ?? {};

    return setPlayerReady(roomId, data, requestOptions);
  };

  return { mutationFn, ...mutationOptions };
};

export type SetPlayerReadyMutationResult = NonNullable<
  Awaited<ReturnType<typeof setPlayerReady>>
>;
export type SetPlayerReadyMutationBody = BodyType<ReadyRequest>;
export type SetPlayerReadyMutationError = ErrorType<ErrorResponse>;

/**
 * @summary Toggle player ready state
 */
export const useSetPlayerReady = <
  TError = ErrorType<ErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof setPlayerReady>>,
    TError,
    { roomId: string; data: BodyType<ReadyRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationResult<
  Awaited<ReturnType<typeof setPlayerReady>>,
  TError,
  { roomId: string; data: BodyType<ReadyRequest> },
  TContext
> => {
  return useMutation(getSetPlayerReadyMutationOptions(options));
};

/**
 * @summary Start the game (host only, all players must be ready)
 */
export const getStartGameUrl = (roomId: string) => {
  return `/api/rooms/${roomId}/start`;
};

export const startGame = async (
  roomId: string,
  startGameRequest: StartGameRequest,
  options?: RequestInit,
): Promise<Room> => {
  return customFetch<Room>(getStartGameUrl(roomId), {
    ...options,
    method: "POST",
    headers: { "Content-Type": "application/json", ...options?.headers },
    body: JSON.stringify(startGameRequest),
  });
};

export const getStartGameMutationOptions = <
  TError = ErrorType<ErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof startGame>>,
    TError,
    { roomId: string; data: BodyType<StartGameRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof startGame>>,
  TError,
  { roomId: string; data: BodyType<StartGameRequest> },
  TContext
> => {
  const mutationKey = ["startGame"];
  const { mutation: mutationOptions, request: requestOptions } = options
    ? options.mutation &&
      "mutationKey" in options.mutation &&
      options.mutation.mutationKey
      ? options
      : { ...options, mutation: { ...options.mutation, mutationKey } }
    : { mutation: { mutationKey }, request: undefined };

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof startGame>>,
    { roomId: string; data: BodyType<StartGameRequest> }
  > = (props) => {
    const { roomId, data } = props ?? {};

    return startGame(roomId, data, requestOptions);
  };

  return { mutationFn, ...mutationOptions };
};

export type StartGameMutationResult = NonNullable<
  Awaited<ReturnType<typeof startGame>>
>;
export type StartGameMutationBody = BodyType<StartGameRequest>;
export type StartGameMutationError = ErrorType<ErrorResponse>;

/**
 * @summary Start the game (host only, all players must be ready)
 */
export const useStartGame = <
  TError = ErrorType<ErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof startGame>>,
    TError,
    { roomId: string; data: BodyType<StartGameRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationResult<
  Awaited<ReturnType<typeof startGame>>,
  TError,
  { roomId: string; data: BodyType<StartGameRequest> },
  TContext
> => {
  return useMutation(getStartGameMutationOptions(options));
};

/**
 * @summary Leave a room
 */
export const getLeaveRoomUrl = (roomId: string) => {
  return `/api/rooms/${roomId}/leave`;
};

export const leaveRoom = async (
  roomId: string,
  leaveRoomRequest: LeaveRoomRequest,
  options?: RequestInit,
): Promise<SuccessResponse> => {
  return customFetch<SuccessResponse>(getLeaveRoomUrl(roomId), {
    ...options,
    method: "POST",
    headers: { "Content-Type": "application/json", ...options?.headers },
    body: JSON.stringify(leaveRoomRequest),
  });
};

export const getLeaveRoomMutationOptions = <
  TError = ErrorType<unknown>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof leaveRoom>>,
    TError,
    { roomId: string; data: BodyType<LeaveRoomRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof leaveRoom>>,
  TError,
  { roomId: string; data: BodyType<LeaveRoomRequest> },
  TContext
> => {
  const mutationKey = ["leaveRoom"];
  const { mutation: mutationOptions, request: requestOptions } = options
    ? options.mutation &&
      "mutationKey" in options.mutation &&
      options.mutation.mutationKey
      ? options
      : { ...options, mutation: { ...options.mutation, mutationKey } }
    : { mutation: { mutationKey }, request: undefined };

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof leaveRoom>>,
    { roomId: string; data: BodyType<LeaveRoomRequest> }
  > = (props) => {
    const { roomId, data } = props ?? {};

    return leaveRoom(roomId, data, requestOptions);
  };

  return { mutationFn, ...mutationOptions };
};

export type LeaveRoomMutationResult = NonNullable<
  Awaited<ReturnType<typeof leaveRoom>>
>;
export type LeaveRoomMutationBody = BodyType<LeaveRoomRequest>;
export type LeaveRoomMutationError = ErrorType<unknown>;

/**
 * @summary Leave a room
 */
export const useLeaveRoom = <
  TError = ErrorType<unknown>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof leaveRoom>>,
    TError,
    { roomId: string; data: BodyType<LeaveRoomRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationResult<
  Awaited<ReturnType<typeof leaveRoom>>,
  TError,
  { roomId: string; data: BodyType<LeaveRoomRequest> },
  TContext
> => {
  return useMutation(getLeaveRoomMutationOptions(options));
};

/**
 * @summary Submit score after game ends
 */
export const getSubmitScoreUrl = (roomId: string) => {
  return `/api/rooms/${roomId}/score`;
};

export const submitScore = async (
  roomId: string,
  submitScoreRequest: SubmitScoreRequest,
  options?: RequestInit,
): Promise<ScoreResult> => {
  return customFetch<ScoreResult>(getSubmitScoreUrl(roomId), {
    ...options,
    method: "POST",
    headers: { "Content-Type": "application/json", ...options?.headers },
    body: JSON.stringify(submitScoreRequest),
  });
};

export const getSubmitScoreMutationOptions = <
  TError = ErrorType<unknown>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof submitScore>>,
    TError,
    { roomId: string; data: BodyType<SubmitScoreRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof submitScore>>,
  TError,
  { roomId: string; data: BodyType<SubmitScoreRequest> },
  TContext
> => {
  const mutationKey = ["submitScore"];
  const { mutation: mutationOptions, request: requestOptions } = options
    ? options.mutation &&
      "mutationKey" in options.mutation &&
      options.mutation.mutationKey
      ? options
      : { ...options, mutation: { ...options.mutation, mutationKey } }
    : { mutation: { mutationKey }, request: undefined };

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof submitScore>>,
    { roomId: string; data: BodyType<SubmitScoreRequest> }
  > = (props) => {
    const { roomId, data } = props ?? {};

    return submitScore(roomId, data, requestOptions);
  };

  return { mutationFn, ...mutationOptions };
};

export type SubmitScoreMutationResult = NonNullable<
  Awaited<ReturnType<typeof submitScore>>
>;
export type SubmitScoreMutationBody = BodyType<SubmitScoreRequest>;
export type SubmitScoreMutationError = ErrorType<unknown>;

/**
 * @summary Submit score after game ends
 */
export const useSubmitScore = <
  TError = ErrorType<unknown>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof submitScore>>,
    TError,
    { roomId: string; data: BodyType<SubmitScoreRequest> },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationResult<
  Awaited<ReturnType<typeof submitScore>>,
  TError,
  { roomId: string; data: BodyType<SubmitScoreRequest> },
  TContext
> => {
  return useMutation(getSubmitScoreMutationOptions(options));
};

/**
 * @summary Get player stats and score history
 */
export const getGetPlayerStatsUrl = (playerName: string) => {
  return `/api/players/${playerName}/stats`;
};

export const getPlayerStats = async (
  playerName: string,
  options?: RequestInit,
): Promise<PlayerStats> => {
  return customFetch<PlayerStats>(getGetPlayerStatsUrl(playerName), {
    ...options,
    method: "GET",
  });
};

export const getGetPlayerStatsQueryKey = (playerName: string) => {
  return [`/api/players/${playerName}/stats`] as const;
};

export const getGetPlayerStatsQueryOptions = <
  TData = Awaited<ReturnType<typeof getPlayerStats>>,
  TError = ErrorType<unknown>,
>(
  playerName: string,
  options?: {
    query?: UseQueryOptions<
      Awaited<ReturnType<typeof getPlayerStats>>,
      TError,
      TData
    >;
    request?: SecondParameter<typeof customFetch>;
  },
) => {
  const { query: queryOptions, request: requestOptions } = options ?? {};

  const queryKey =
    queryOptions?.queryKey ?? getGetPlayerStatsQueryKey(playerName);

  const queryFn: QueryFunction<Awaited<ReturnType<typeof getPlayerStats>>> = ({
    signal,
  }) => getPlayerStats(playerName, { signal, ...requestOptions });

  return {
    queryKey,
    queryFn,
    enabled: !!playerName,
    ...queryOptions,
  } as UseQueryOptions<
    Awaited<ReturnType<typeof getPlayerStats>>,
    TError,
    TData
  > & { queryKey: QueryKey };
};

export type GetPlayerStatsQueryResult = NonNullable<
  Awaited<ReturnType<typeof getPlayerStats>>
>;
export type GetPlayerStatsQueryError = ErrorType<unknown>;

/**
 * @summary Get player stats and score history
 */

export function useGetPlayerStats<
  TData = Awaited<ReturnType<typeof getPlayerStats>>,
  TError = ErrorType<unknown>,
>(
  playerName: string,
  options?: {
    query?: UseQueryOptions<
      Awaited<ReturnType<typeof getPlayerStats>>,
      TError,
      TData
    >;
    request?: SecondParameter<typeof customFetch>;
  },
): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
  const queryOptions = getGetPlayerStatsQueryOptions(playerName, options);

  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
  };

  return { ...query, queryKey: queryOptions.queryKey };
}

/**
 * @summary Get global leaderboard
 */
export const getGetLeaderboardUrl = () => {
  return `/api/leaderboard`;
};

export const getLeaderboard = async (
  options?: RequestInit,
): Promise<LeaderboardEntry[]> => {
  return customFetch<LeaderboardEntry[]>(getGetLeaderboardUrl(), {
    ...options,
    method: "GET",
  });
};

export const getGetLeaderboardQueryKey = () => {
  return [`/api/leaderboard`] as const;
};

export const getGetLeaderboardQueryOptions = <
  TData = Awaited<ReturnType<typeof getLeaderboard>>,
  TError = ErrorType<unknown>,
>(options?: {
  query?: UseQueryOptions<
    Awaited<ReturnType<typeof getLeaderboard>>,
    TError,
    TData
  >;
  request?: SecondParameter<typeof customFetch>;
}) => {
  const { query: queryOptions, request: requestOptions } = options ?? {};

  const queryKey = queryOptions?.queryKey ?? getGetLeaderboardQueryKey();

  const queryFn: QueryFunction<Awaited<ReturnType<typeof getLeaderboard>>> = ({
    signal,
  }) => getLeaderboard({ signal, ...requestOptions });

  return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
    Awaited<ReturnType<typeof getLeaderboard>>,
    TError,
    TData
  > & { queryKey: QueryKey };
};

export type GetLeaderboardQueryResult = NonNullable<
  Awaited<ReturnType<typeof getLeaderboard>>
>;
export type GetLeaderboardQueryError = ErrorType<unknown>;

/**
 * @summary Get global leaderboard
 */

export function useGetLeaderboard<
  TData = Awaited<ReturnType<typeof getLeaderboard>>,
  TError = ErrorType<unknown>,
>(options?: {
  query?: UseQueryOptions<
    Awaited<ReturnType<typeof getLeaderboard>>,
    TError,
    TData
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
  const queryOptions = getGetLeaderboardQueryOptions(options);

  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
  };

  return { ...query, queryKey: queryOptions.queryKey };
}

/**
 * @summary Get player achievements
 */
export const getGetAchievementsUrl = (playerName: string) => {
  return `/api/achievements/${playerName}`;
};

export const getAchievements = async (
  playerName: string,
  options?: RequestInit,
): Promise<AchievementsData> => {
  return customFetch<AchievementsData>(getGetAchievementsUrl(playerName), {
    ...options,
    method: "GET",
  });
};

export const getGetAchievementsQueryKey = (playerName: string) => {
  return [`/api/achievements/${playerName}`] as const;
};

export const getGetAchievementsQueryOptions = <
  TData = Awaited<ReturnType<typeof getAchievements>>,
  TError = ErrorType<unknown>,
>(
  playerName: string,
  options?: {
    query?: UseQueryOptions<
      Awaited<ReturnType<typeof getAchievements>>,
      TError,
      TData
    >;
    request?: SecondParameter<typeof customFetch>;
  },
) => {
  const { query: queryOptions, request: requestOptions } = options ?? {};

  const queryKey =
    queryOptions?.queryKey ?? getGetAchievementsQueryKey(playerName);

  const queryFn: QueryFunction<Awaited<ReturnType<typeof getAchievements>>> = ({
    signal,
  }) => getAchievements(playerName, { signal, ...requestOptions });

  return {
    queryKey,
    queryFn,
    enabled: !!playerName,
    ...queryOptions,
  } as UseQueryOptions<
    Awaited<ReturnType<typeof getAchievements>>,
    TError,
    TData
  > & { queryKey: QueryKey };
};

export type GetAchievementsQueryResult = NonNullable<
  Awaited<ReturnType<typeof getAchievements>>
>;
export type GetAchievementsQueryError = ErrorType<unknown>;

/**
 * @summary Get player achievements
 */

export function useGetAchievements<
  TData = Awaited<ReturnType<typeof getAchievements>>,
  TError = ErrorType<unknown>,
>(
  playerName: string,
  options?: {
    query?: UseQueryOptions<
      Awaited<ReturnType<typeof getAchievements>>,
      TError,
      TData
    >;
    request?: SecondParameter<typeof customFetch>;
  },
): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
  const queryOptions = getGetAchievementsQueryOptions(playerName, options);

  const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
  };

  return { ...query, queryKey: queryOptions.queryKey };
}