unlockpage-api-client/src/generated/api.ts

React hooks and TypeScript client for Unlockpage API

/**
 * Generated by orval v6.31.0 🍺
 * Do not edit manually.
 * Unlockpage API
 * This is the API server for Unlockpage micropayments platform.
 * OpenAPI spec version: 1.0
 */
import { useMutation, useQuery } from "@tanstack/react-query";
import type {
  MutationFunction,
  QueryFunction,
  QueryKey,
  UseMutationOptions,
  UseMutationResult,
  UseQueryOptions,
  UseQueryResult,
} from "@tanstack/react-query";
import axios from "axios";
import type { AxiosError, AxiosRequestConfig, AxiosResponse } from "axios";
import type {
  BodyBody,
  DeleteRoutesParams,
  DeleteWebsiteParams,
  GetAuthCheck200,
  GetAvaliableParams,
  GetDns400,
  GetDns404,
  GetDns500,
  GetDnsParams,
  GetPluginVerifyParams,
  GetPurchaseHistoryParams,
  GetWebsiteIdSigningKey200,
  GetWebsiteParams,
  MicrohttpAccessResponse,
  MicrohttpDNSResponse,
  MicrohttpErrorResponse,
  MicrohttpPluginVerifyRequestBody,
  MicrohttpPluginVerifyResponse,
  MicrohttpPurchaseDetail,
  MicrohttpRoute,
  MicrohttpRouteInfo,
  MicrohttpUser,
  MicrohttpWebsite,
  PatchRoutesBody,
  PatchRoutesParams,
  PostAccessBody,
  PostDns400,
  PostDns404,
  PostDns500,
  PostDnsParams,
  PostPluginVerifyParams,
  PostUserLogout200,
  PutUser200,
} from "./model";

/**
 * Verify if user has purchased access to a specific URL/route
 * @summary Check access to protected content
 */
export const postAccess = (
  postAccessBody: PostAccessBody,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpAccessResponse>> => {
  return axios.post(
    `https://api.unlockpage.com/access`,
    postAccessBody,
    options,
  );
};

export const getPostAccessMutationOptions = <
  TError = AxiosError<MicrohttpErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof postAccess>>,
    TError,
    { data: PostAccessBody },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationOptions<
  Awaited<ReturnType<typeof postAccess>>,
  TError,
  { data: PostAccessBody },
  TContext
> => {
  const { mutation: mutationOptions, axios: axiosOptions } = options ?? {};

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof postAccess>>,
    { data: PostAccessBody }
  > = (props) => {
    const { data } = props ?? {};

    return postAccess(data, axiosOptions);
  };

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

export type PostAccessMutationResult = NonNullable<
  Awaited<ReturnType<typeof postAccess>>
>;
export type PostAccessMutationBody = PostAccessBody;
export type PostAccessMutationError = AxiosError<MicrohttpErrorResponse>;

/**
 * @summary Check access to protected content
 */
export const usePostAccess = <
  TError = AxiosError<MicrohttpErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof postAccess>>,
    TError,
    { data: PostAccessBody },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationResult<
  Awaited<ReturnType<typeof postAccess>>,
  TError,
  { data: PostAccessBody },
  TContext
> => {
  const mutationOptions = getPostAccessMutationOptions(options);

  return useMutation(mutationOptions);
};

/**
 * Check if user has a valid session cookie
 * @summary Check authentication status
 */
export const getAuthCheck = (
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<GetAuthCheck200>> => {
  return axios.get(`https://api.unlockpage.com/auth/check`, options);
};

export const getGetAuthCheckQueryKey = () => {
  return [`https://api.unlockpage.com/auth/check`] as const;
};

export const getGetAuthCheckQueryOptions = <
  TData = Awaited<ReturnType<typeof getAuthCheck>>,
  TError = AxiosError<string>,
>(options?: {
  query?: Partial<
    UseQueryOptions<Awaited<ReturnType<typeof getAuthCheck>>, TError, TData>
  >;
  axios?: AxiosRequestConfig;
}) => {
  const { query: queryOptions, axios: axiosOptions } = options ?? {};

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

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

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

export type GetAuthCheckQueryResult = NonNullable<
  Awaited<ReturnType<typeof getAuthCheck>>
>;
export type GetAuthCheckQueryError = AxiosError<string>;

/**
 * @summary Check authentication status
 */
export const useGetAuthCheck = <
  TData = Awaited<ReturnType<typeof getAuthCheck>>,
  TError = AxiosError<string>,
>(options?: {
  query?: Partial<
    UseQueryOptions<Awaited<ReturnType<typeof getAuthCheck>>, TError, TData>
  >;
  axios?: AxiosRequestConfig;
}): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
  const queryOptions = getGetAuthCheckQueryOptions(options);

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

  query.queryKey = queryOptions.queryKey;

  return query;
};

/**
 * Check if a route is available for purchase and get route information
 * @summary Check route availability
 */
export const getAvaliable = (
  params: GetAvaliableParams,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpRouteInfo>> => {
  return axios.get(`https://api.unlockpage.com/avaliable`, {
    ...options,
    params: { ...params, ...options?.params },
  });
};

export const getGetAvaliableQueryKey = (params: GetAvaliableParams) => {
  return [
    `https://api.unlockpage.com/avaliable`,
    ...(params ? [params] : []),
  ] as const;
};

export const getGetAvaliableQueryOptions = <
  TData = Awaited<ReturnType<typeof getAvaliable>>,
  TError = AxiosError<MicrohttpErrorResponse>,
>(
  params: GetAvaliableParams,
  options?: {
    query?: Partial<
      UseQueryOptions<Awaited<ReturnType<typeof getAvaliable>>, TError, TData>
    >;
    axios?: AxiosRequestConfig;
  },
) => {
  const { query: queryOptions, axios: axiosOptions } = options ?? {};

  const queryKey = queryOptions?.queryKey ?? getGetAvaliableQueryKey(params);

  const queryFn: QueryFunction<Awaited<ReturnType<typeof getAvaliable>>> = ({
    signal,
  }) => getAvaliable(params, { signal, ...axiosOptions });

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

export type GetAvaliableQueryResult = NonNullable<
  Awaited<ReturnType<typeof getAvaliable>>
>;
export type GetAvaliableQueryError = AxiosError<MicrohttpErrorResponse>;

/**
 * @summary Check route availability
 */
export const useGetAvaliable = <
  TData = Awaited<ReturnType<typeof getAvaliable>>,
  TError = AxiosError<MicrohttpErrorResponse>,
>(
  params: GetAvaliableParams,
  options?: {
    query?: Partial<
      UseQueryOptions<Awaited<ReturnType<typeof getAvaliable>>, TError, TData>
    >;
    axios?: AxiosRequestConfig;
  },
): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
  const queryOptions = getGetAvaliableQueryOptions(params, options);

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

  query.queryKey = queryOptions.queryKey;

  return query;
};

/**
 * GET: Check DNS TXT record verification status, POST: Generate new TXT record for domain verification
 * @summary DNS management for domain verification
 */
export const getDns = (
  bodyBody: BodyBody,
  params: GetDnsParams,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpDNSResponse>> => {
  return axios.get(`https://api.unlockpage.com/dns`, {
    ...options,
    params: { ...params, ...options?.params },
  });
};

export const getGetDnsQueryKey = (bodyBody: BodyBody, params: GetDnsParams) => {
  return [
    `https://api.unlockpage.com/dns`,
    ...(params ? [params] : []),
    bodyBody,
  ] as const;
};

export const getGetDnsQueryOptions = <
  TData = Awaited<ReturnType<typeof getDns>>,
  TError = AxiosError<GetDns400 | GetDns404 | GetDns500>,
>(
  bodyBody: BodyBody,
  params: GetDnsParams,
  options?: {
    query?: Partial<
      UseQueryOptions<Awaited<ReturnType<typeof getDns>>, TError, TData>
    >;
    axios?: AxiosRequestConfig;
  },
) => {
  const { query: queryOptions, axios: axiosOptions } = options ?? {};

  const queryKey =
    queryOptions?.queryKey ?? getGetDnsQueryKey(bodyBody, params);

  const queryFn: QueryFunction<Awaited<ReturnType<typeof getDns>>> = ({
    signal,
  }) => getDns(bodyBody, params, { signal, ...axiosOptions });

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

export type GetDnsQueryResult = NonNullable<Awaited<ReturnType<typeof getDns>>>;
export type GetDnsQueryError = AxiosError<GetDns400 | GetDns404 | GetDns500>;

/**
 * @summary DNS management for domain verification
 */
export const useGetDns = <
  TData = Awaited<ReturnType<typeof getDns>>,
  TError = AxiosError<GetDns400 | GetDns404 | GetDns500>,
>(
  bodyBody: BodyBody,
  params: GetDnsParams,
  options?: {
    query?: Partial<
      UseQueryOptions<Awaited<ReturnType<typeof getDns>>, TError, TData>
    >;
    axios?: AxiosRequestConfig;
  },
): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
  const queryOptions = getGetDnsQueryOptions(bodyBody, params, options);

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

  query.queryKey = queryOptions.queryKey;

  return query;
};

/**
 * GET: Check DNS TXT record verification status, POST: Generate new TXT record for domain verification
 * @summary DNS management for domain verification
 */
export const postDns = (
  bodyBody: BodyBody,
  params: PostDnsParams,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpDNSResponse>> => {
  return axios.post(`https://api.unlockpage.com/dns`, bodyBody, {
    ...options,
    params: { ...params, ...options?.params },
  });
};

export const getPostDnsMutationOptions = <
  TError = AxiosError<PostDns400 | PostDns404 | PostDns500>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof postDns>>,
    TError,
    { data: BodyBody; params: PostDnsParams },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationOptions<
  Awaited<ReturnType<typeof postDns>>,
  TError,
  { data: BodyBody; params: PostDnsParams },
  TContext
> => {
  const { mutation: mutationOptions, axios: axiosOptions } = options ?? {};

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof postDns>>,
    { data: BodyBody; params: PostDnsParams }
  > = (props) => {
    const { data, params } = props ?? {};

    return postDns(data, params, axiosOptions);
  };

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

export type PostDnsMutationResult = NonNullable<
  Awaited<ReturnType<typeof postDns>>
>;
export type PostDnsMutationBody = BodyBody;
export type PostDnsMutationError = AxiosError<
  PostDns400 | PostDns404 | PostDns500
>;

/**
 * @summary DNS management for domain verification
 */
export const usePostDns = <
  TError = AxiosError<PostDns400 | PostDns404 | PostDns500>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof postDns>>,
    TError,
    { data: BodyBody; params: PostDnsParams },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationResult<
  Awaited<ReturnType<typeof postDns>>,
  TError,
  { data: BodyBody; params: PostDnsParams },
  TContext
> => {
  const mutationOptions = getPostDnsMutationOptions(options);

  return useMutation(mutationOptions);
};

/**
 * Get purchase history for websites owned by the authenticated user
 * @summary Get website purchase history
 */
export const getDomainsPurchaseHistory = (
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpPurchaseDetail[]>> => {
  return axios.get(
    `https://api.unlockpage.com/domains-purchase-history`,
    options,
  );
};

export const getGetDomainsPurchaseHistoryQueryKey = () => {
  return [`https://api.unlockpage.com/domains-purchase-history`] as const;
};

export const getGetDomainsPurchaseHistoryQueryOptions = <
  TData = Awaited<ReturnType<typeof getDomainsPurchaseHistory>>,
  TError = AxiosError<MicrohttpErrorResponse>,
>(options?: {
  query?: Partial<
    UseQueryOptions<
      Awaited<ReturnType<typeof getDomainsPurchaseHistory>>,
      TError,
      TData
    >
  >;
  axios?: AxiosRequestConfig;
}) => {
  const { query: queryOptions, axios: axiosOptions } = options ?? {};

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

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

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

export type GetDomainsPurchaseHistoryQueryResult = NonNullable<
  Awaited<ReturnType<typeof getDomainsPurchaseHistory>>
>;
export type GetDomainsPurchaseHistoryQueryError =
  AxiosError<MicrohttpErrorResponse>;

/**
 * @summary Get website purchase history
 */
export const useGetDomainsPurchaseHistory = <
  TData = Awaited<ReturnType<typeof getDomainsPurchaseHistory>>,
  TError = AxiosError<MicrohttpErrorResponse>,
>(options?: {
  query?: Partial<
    UseQueryOptions<
      Awaited<ReturnType<typeof getDomainsPurchaseHistory>>,
      TError,
      TData
    >
  >;
  axios?: AxiosRequestConfig;
}): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
  const queryOptions = getGetDomainsPurchaseHistoryQueryOptions(options);

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

  query.queryKey = queryOptions.queryKey;

  return query;
};

/**
 * GET: Check plugin verification status, POST: Generate new plugin token for verification
 * @summary WordPress plugin verification for domain ownership
 */
export const getPluginVerify = (
  microhttpPluginVerifyRequestBody: MicrohttpPluginVerifyRequestBody,
  params: GetPluginVerifyParams,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpPluginVerifyResponse>> => {
  return axios.get(`https://api.unlockpage.com/plugin-verify`, {
    ...options,
    params: { ...params, ...options?.params },
  });
};

export const getGetPluginVerifyQueryKey = (
  microhttpPluginVerifyRequestBody: MicrohttpPluginVerifyRequestBody,
  params: GetPluginVerifyParams,
) => {
  return [
    `https://api.unlockpage.com/plugin-verify`,
    ...(params ? [params] : []),
    microhttpPluginVerifyRequestBody,
  ] as const;
};

export const getGetPluginVerifyQueryOptions = <
  TData = Awaited<ReturnType<typeof getPluginVerify>>,
  TError = AxiosError<MicrohttpPluginVerifyResponse>,
>(
  microhttpPluginVerifyRequestBody: MicrohttpPluginVerifyRequestBody,
  params: GetPluginVerifyParams,
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof getPluginVerify>>,
        TError,
        TData
      >
    >;
    axios?: AxiosRequestConfig;
  },
) => {
  const { query: queryOptions, axios: axiosOptions } = options ?? {};

  const queryKey =
    queryOptions?.queryKey ??
    getGetPluginVerifyQueryKey(microhttpPluginVerifyRequestBody, params);

  const queryFn: QueryFunction<Awaited<ReturnType<typeof getPluginVerify>>> = ({
    signal,
  }) =>
    getPluginVerify(microhttpPluginVerifyRequestBody, params, {
      signal,
      ...axiosOptions,
    });

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

export type GetPluginVerifyQueryResult = NonNullable<
  Awaited<ReturnType<typeof getPluginVerify>>
>;
export type GetPluginVerifyQueryError =
  AxiosError<MicrohttpPluginVerifyResponse>;

/**
 * @summary WordPress plugin verification for domain ownership
 */
export const useGetPluginVerify = <
  TData = Awaited<ReturnType<typeof getPluginVerify>>,
  TError = AxiosError<MicrohttpPluginVerifyResponse>,
>(
  microhttpPluginVerifyRequestBody: MicrohttpPluginVerifyRequestBody,
  params: GetPluginVerifyParams,
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof getPluginVerify>>,
        TError,
        TData
      >
    >;
    axios?: AxiosRequestConfig;
  },
): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
  const queryOptions = getGetPluginVerifyQueryOptions(
    microhttpPluginVerifyRequestBody,
    params,
    options,
  );

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

  query.queryKey = queryOptions.queryKey;

  return query;
};

/**
 * GET: Check plugin verification status, POST: Generate new plugin token for verification
 * @summary WordPress plugin verification for domain ownership
 */
export const postPluginVerify = (
  microhttpPluginVerifyRequestBody: MicrohttpPluginVerifyRequestBody,
  params: PostPluginVerifyParams,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpPluginVerifyResponse>> => {
  return axios.post(
    `https://api.unlockpage.com/plugin-verify`,
    microhttpPluginVerifyRequestBody,
    {
      ...options,
      params: { ...params, ...options?.params },
    },
  );
};

export const getPostPluginVerifyMutationOptions = <
  TError = AxiosError<MicrohttpPluginVerifyResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof postPluginVerify>>,
    TError,
    { data: MicrohttpPluginVerifyRequestBody; params: PostPluginVerifyParams },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationOptions<
  Awaited<ReturnType<typeof postPluginVerify>>,
  TError,
  { data: MicrohttpPluginVerifyRequestBody; params: PostPluginVerifyParams },
  TContext
> => {
  const { mutation: mutationOptions, axios: axiosOptions } = options ?? {};

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof postPluginVerify>>,
    { data: MicrohttpPluginVerifyRequestBody; params: PostPluginVerifyParams }
  > = (props) => {
    const { data, params } = props ?? {};

    return postPluginVerify(data, params, axiosOptions);
  };

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

export type PostPluginVerifyMutationResult = NonNullable<
  Awaited<ReturnType<typeof postPluginVerify>>
>;
export type PostPluginVerifyMutationBody = MicrohttpPluginVerifyRequestBody;
export type PostPluginVerifyMutationError =
  AxiosError<MicrohttpPluginVerifyResponse>;

/**
 * @summary WordPress plugin verification for domain ownership
 */
export const usePostPluginVerify = <
  TError = AxiosError<MicrohttpPluginVerifyResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof postPluginVerify>>,
    TError,
    { data: MicrohttpPluginVerifyRequestBody; params: PostPluginVerifyParams },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationResult<
  Awaited<ReturnType<typeof postPluginVerify>>,
  TError,
  { data: MicrohttpPluginVerifyRequestBody; params: PostPluginVerifyParams },
  TContext
> => {
  const mutationOptions = getPostPluginVerifyMutationOptions(options);

  return useMutation(mutationOptions);
};

/**
 * Get all purchases made by the authenticated user
 * @summary Get user purchase history
 */
export const getPurchaseHistory = (
  params?: GetPurchaseHistoryParams,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpPurchaseDetail[]>> => {
  return axios.get(`https://api.unlockpage.com/purchase-history`, {
    ...options,
    params: { ...params, ...options?.params },
  });
};

export const getGetPurchaseHistoryQueryKey = (
  params?: GetPurchaseHistoryParams,
) => {
  return [
    `https://api.unlockpage.com/purchase-history`,
    ...(params ? [params] : []),
  ] as const;
};

export const getGetPurchaseHistoryQueryOptions = <
  TData = Awaited<ReturnType<typeof getPurchaseHistory>>,
  TError = AxiosError<MicrohttpErrorResponse>,
>(
  params?: GetPurchaseHistoryParams,
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof getPurchaseHistory>>,
        TError,
        TData
      >
    >;
    axios?: AxiosRequestConfig;
  },
) => {
  const { query: queryOptions, axios: axiosOptions } = options ?? {};

  const queryKey =
    queryOptions?.queryKey ?? getGetPurchaseHistoryQueryKey(params);

  const queryFn: QueryFunction<
    Awaited<ReturnType<typeof getPurchaseHistory>>
  > = ({ signal }) => getPurchaseHistory(params, { signal, ...axiosOptions });

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

export type GetPurchaseHistoryQueryResult = NonNullable<
  Awaited<ReturnType<typeof getPurchaseHistory>>
>;
export type GetPurchaseHistoryQueryError = AxiosError<MicrohttpErrorResponse>;

/**
 * @summary Get user purchase history
 */
export const useGetPurchaseHistory = <
  TData = Awaited<ReturnType<typeof getPurchaseHistory>>,
  TError = AxiosError<MicrohttpErrorResponse>,
>(
  params?: GetPurchaseHistoryParams,
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof getPurchaseHistory>>,
        TError,
        TData
      >
    >;
    axios?: AxiosRequestConfig;
  },
): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
  const queryOptions = getGetPurchaseHistoryQueryOptions(params, options);

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

  query.queryKey = queryOptions.queryKey;

  return query;
};

/**
 * Retrieve all routes for websites owned by the authenticated user
 * @summary Get user's routes
 */
export const getRoutes = (
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpRoute[]>> => {
  return axios.get(`https://api.unlockpage.com/routes`, options);
};

export const getGetRoutesQueryKey = () => {
  return [`https://api.unlockpage.com/routes`] as const;
};

export const getGetRoutesQueryOptions = <
  TData = Awaited<ReturnType<typeof getRoutes>>,
  TError = AxiosError<string>,
>(options?: {
  query?: Partial<
    UseQueryOptions<Awaited<ReturnType<typeof getRoutes>>, TError, TData>
  >;
  axios?: AxiosRequestConfig;
}) => {
  const { query: queryOptions, axios: axiosOptions } = options ?? {};

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

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

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

export type GetRoutesQueryResult = NonNullable<
  Awaited<ReturnType<typeof getRoutes>>
>;
export type GetRoutesQueryError = AxiosError<string>;

/**
 * @summary Get user's routes
 */
export const useGetRoutes = <
  TData = Awaited<ReturnType<typeof getRoutes>>,
  TError = AxiosError<string>,
>(options?: {
  query?: Partial<
    UseQueryOptions<Awaited<ReturnType<typeof getRoutes>>, TError, TData>
  >;
  axios?: AxiosRequestConfig;
}): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
  const queryOptions = getGetRoutesQueryOptions(options);

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

  query.queryKey = queryOptions.queryKey;

  return query;
};

/**
 * Add a new route for a website that users can purchase access to
 * @summary Register a new route
 */
export const putRoutes = (
  microhttpRoute: MicrohttpRoute,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<string>> => {
  return axios.put(
    `https://api.unlockpage.com/routes`,
    microhttpRoute,
    options,
  );
};

export const getPutRoutesMutationOptions = <
  TError = AxiosError<string>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof putRoutes>>,
    TError,
    { data: MicrohttpRoute },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationOptions<
  Awaited<ReturnType<typeof putRoutes>>,
  TError,
  { data: MicrohttpRoute },
  TContext
> => {
  const { mutation: mutationOptions, axios: axiosOptions } = options ?? {};

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof putRoutes>>,
    { data: MicrohttpRoute }
  > = (props) => {
    const { data } = props ?? {};

    return putRoutes(data, axiosOptions);
  };

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

export type PutRoutesMutationResult = NonNullable<
  Awaited<ReturnType<typeof putRoutes>>
>;
export type PutRoutesMutationBody = MicrohttpRoute;
export type PutRoutesMutationError = AxiosError<string>;

/**
 * @summary Register a new route
 */
export const usePutRoutes = <
  TError = AxiosError<string>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof putRoutes>>,
    TError,
    { data: MicrohttpRoute },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationResult<
  Awaited<ReturnType<typeof putRoutes>>,
  TError,
  { data: MicrohttpRoute },
  TContext
> => {
  const mutationOptions = getPutRoutesMutationOptions(options);

  return useMutation(mutationOptions);
};

/**
 * Delete a route. Can only delete if no purchases exist for the route
 * @summary Delete an existing route
 */
export const deleteRoutes = (
  params: DeleteRoutesParams,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<string>> => {
  return axios.delete(`https://api.unlockpage.com/routes`, {
    ...options,
    params: { ...params, ...options?.params },
  });
};

export const getDeleteRoutesMutationOptions = <
  TError = AxiosError<MicrohttpErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof deleteRoutes>>,
    TError,
    { params: DeleteRoutesParams },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationOptions<
  Awaited<ReturnType<typeof deleteRoutes>>,
  TError,
  { params: DeleteRoutesParams },
  TContext
> => {
  const { mutation: mutationOptions, axios: axiosOptions } = options ?? {};

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof deleteRoutes>>,
    { params: DeleteRoutesParams }
  > = (props) => {
    const { params } = props ?? {};

    return deleteRoutes(params, axiosOptions);
  };

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

export type DeleteRoutesMutationResult = NonNullable<
  Awaited<ReturnType<typeof deleteRoutes>>
>;

export type DeleteRoutesMutationError = AxiosError<MicrohttpErrorResponse>;

/**
 * @summary Delete an existing route
 */
export const useDeleteRoutes = <
  TError = AxiosError<MicrohttpErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof deleteRoutes>>,
    TError,
    { params: DeleteRoutesParams },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationResult<
  Awaited<ReturnType<typeof deleteRoutes>>,
  TError,
  { params: DeleteRoutesParams },
  TContext
> => {
  const mutationOptions = getDeleteRoutesMutationOptions(options);

  return useMutation(mutationOptions);
};

/**
 * Update route path, cost, and/or disabled state. Can only update if no purchases exist and new route name doesn't conflict
 * @summary Update an existing route
 */
export const patchRoutes = (
  patchRoutesBody: PatchRoutesBody,
  params: PatchRoutesParams,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<string>> => {
  return axios.patch(`https://api.unlockpage.com/routes`, patchRoutesBody, {
    ...options,
    params: { ...params, ...options?.params },
  });
};

export const getPatchRoutesMutationOptions = <
  TError = AxiosError<MicrohttpErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof patchRoutes>>,
    TError,
    { data: PatchRoutesBody; params: PatchRoutesParams },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationOptions<
  Awaited<ReturnType<typeof patchRoutes>>,
  TError,
  { data: PatchRoutesBody; params: PatchRoutesParams },
  TContext
> => {
  const { mutation: mutationOptions, axios: axiosOptions } = options ?? {};

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof patchRoutes>>,
    { data: PatchRoutesBody; params: PatchRoutesParams }
  > = (props) => {
    const { data, params } = props ?? {};

    return patchRoutes(data, params, axiosOptions);
  };

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

export type PatchRoutesMutationResult = NonNullable<
  Awaited<ReturnType<typeof patchRoutes>>
>;
export type PatchRoutesMutationBody = PatchRoutesBody;
export type PatchRoutesMutationError = AxiosError<MicrohttpErrorResponse>;

/**
 * @summary Update an existing route
 */
export const usePatchRoutes = <
  TError = AxiosError<MicrohttpErrorResponse>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof patchRoutes>>,
    TError,
    { data: PatchRoutesBody; params: PatchRoutesParams },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationResult<
  Awaited<ReturnType<typeof patchRoutes>>,
  TError,
  { data: PatchRoutesBody; params: PatchRoutesParams },
  TContext
> => {
  const mutationOptions = getPatchRoutesMutationOptions(options);

  return useMutation(mutationOptions);
};

/**
 * Retrieve authenticated user's profile information
 * @summary Get user information
 */
export const getUser = (
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpUser>> => {
  return axios.get(`https://api.unlockpage.com/user`, options);
};

export const getGetUserQueryKey = () => {
  return [`https://api.unlockpage.com/user`] as const;
};

export const getGetUserQueryOptions = <
  TData = Awaited<ReturnType<typeof getUser>>,
  TError = AxiosError<string>,
>(options?: {
  query?: Partial<
    UseQueryOptions<Awaited<ReturnType<typeof getUser>>, TError, TData>
  >;
  axios?: AxiosRequestConfig;
}) => {
  const { query: queryOptions, axios: axiosOptions } = options ?? {};

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

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

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

export type GetUserQueryResult = NonNullable<
  Awaited<ReturnType<typeof getUser>>
>;
export type GetUserQueryError = AxiosError<string>;

/**
 * @summary Get user information
 */
export const useGetUser = <
  TData = Awaited<ReturnType<typeof getUser>>,
  TError = AxiosError<string>,
>(options?: {
  query?: Partial<
    UseQueryOptions<Awaited<ReturnType<typeof getUser>>, TError, TData>
  >;
  axios?: AxiosRequestConfig;
}): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
  const queryOptions = getGetUserQueryOptions(options);

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

  query.queryKey = queryOptions.queryKey;

  return query;
};

/**
 * Synchronize user data from JWT token and create secure session
 * @summary Sync user data
 */
export const putUser = (
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<PutUser200>> => {
  return axios.put(`https://api.unlockpage.com/user`, undefined, options);
};

export const getPutUserMutationOptions = <
  TError = AxiosError<string>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof putUser>>,
    TError,
    void,
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationOptions<
  Awaited<ReturnType<typeof putUser>>,
  TError,
  void,
  TContext
> => {
  const { mutation: mutationOptions, axios: axiosOptions } = options ?? {};

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof putUser>>,
    void
  > = () => {
    return putUser(axiosOptions);
  };

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

export type PutUserMutationResult = NonNullable<
  Awaited<ReturnType<typeof putUser>>
>;

export type PutUserMutationError = AxiosError<string>;

/**
 * @summary Sync user data
 */
export const usePutUser = <
  TError = AxiosError<string>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof putUser>>,
    TError,
    void,
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationResult<
  Awaited<ReturnType<typeof putUser>>,
  TError,
  void,
  TContext
> => {
  const mutationOptions = getPutUserMutationOptions(options);

  return useMutation(mutationOptions);
};

/**
 * Log out user by clearing session cookie and deleting session from database
 * @summary User logout
 */
export const postUserLogout = (
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<PostUserLogout200>> => {
  return axios.post(
    `https://api.unlockpage.com/user/logout`,
    undefined,
    options,
  );
};

export const getPostUserLogoutMutationOptions = <
  TError = AxiosError<string>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof postUserLogout>>,
    TError,
    void,
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationOptions<
  Awaited<ReturnType<typeof postUserLogout>>,
  TError,
  void,
  TContext
> => {
  const { mutation: mutationOptions, axios: axiosOptions } = options ?? {};

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof postUserLogout>>,
    void
  > = () => {
    return postUserLogout(axiosOptions);
  };

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

export type PostUserLogoutMutationResult = NonNullable<
  Awaited<ReturnType<typeof postUserLogout>>
>;

export type PostUserLogoutMutationError = AxiosError<string>;

/**
 * @summary User logout
 */
export const usePostUserLogout = <
  TError = AxiosError<string>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof postUserLogout>>,
    TError,
    void,
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationResult<
  Awaited<ReturnType<typeof postUserLogout>>,
  TError,
  void,
  TContext
> => {
  const mutationOptions = getPostUserLogoutMutationOptions(options);

  return useMutation(mutationOptions);
};

/**
 * Retrieve all websites registered by the authenticated user
 * @summary Get user's websites
 */
export const getWebsite = (
  params?: GetWebsiteParams,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<MicrohttpWebsite[]>> => {
  return axios.get(`https://api.unlockpage.com/website`, {
    ...options,
    params: { ...params, ...options?.params },
  });
};

export const getGetWebsiteQueryKey = (params?: GetWebsiteParams) => {
  return [
    `https://api.unlockpage.com/website`,
    ...(params ? [params] : []),
  ] as const;
};

export const getGetWebsiteQueryOptions = <
  TData = Awaited<ReturnType<typeof getWebsite>>,
  TError = AxiosError<string>,
>(
  params?: GetWebsiteParams,
  options?: {
    query?: Partial<
      UseQueryOptions<Awaited<ReturnType<typeof getWebsite>>, TError, TData>
    >;
    axios?: AxiosRequestConfig;
  },
) => {
  const { query: queryOptions, axios: axiosOptions } = options ?? {};

  const queryKey = queryOptions?.queryKey ?? getGetWebsiteQueryKey(params);

  const queryFn: QueryFunction<Awaited<ReturnType<typeof getWebsite>>> = ({
    signal,
  }) => getWebsite(params, { signal, ...axiosOptions });

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

export type GetWebsiteQueryResult = NonNullable<
  Awaited<ReturnType<typeof getWebsite>>
>;
export type GetWebsiteQueryError = AxiosError<string>;

/**
 * @summary Get user's websites
 */
export const useGetWebsite = <
  TData = Awaited<ReturnType<typeof getWebsite>>,
  TError = AxiosError<string>,
>(
  params?: GetWebsiteParams,
  options?: {
    query?: Partial<
      UseQueryOptions<Awaited<ReturnType<typeof getWebsite>>, TError, TData>
    >;
    axios?: AxiosRequestConfig;
  },
): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
  const queryOptions = getGetWebsiteQueryOptions(params, options);

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

  query.queryKey = queryOptions.queryKey;

  return query;
};

/**
 * Register a new website for content monetization
 * @summary Register a new website
 */
export const putWebsite = (
  microhttpWebsite: MicrohttpWebsite,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<string>> => {
  return axios.put(
    `https://api.unlockpage.com/website`,
    microhttpWebsite,
    options,
  );
};

export const getPutWebsiteMutationOptions = <
  TError = AxiosError<string>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof putWebsite>>,
    TError,
    { data: MicrohttpWebsite },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationOptions<
  Awaited<ReturnType<typeof putWebsite>>,
  TError,
  { data: MicrohttpWebsite },
  TContext
> => {
  const { mutation: mutationOptions, axios: axiosOptions } = options ?? {};

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof putWebsite>>,
    { data: MicrohttpWebsite }
  > = (props) => {
    const { data } = props ?? {};

    return putWebsite(data, axiosOptions);
  };

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

export type PutWebsiteMutationResult = NonNullable<
  Awaited<ReturnType<typeof putWebsite>>
>;
export type PutWebsiteMutationBody = MicrohttpWebsite;
export type PutWebsiteMutationError = AxiosError<string>;

/**
 * @summary Register a new website
 */
export const usePutWebsite = <
  TError = AxiosError<string>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof putWebsite>>,
    TError,
    { data: MicrohttpWebsite },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationResult<
  Awaited<ReturnType<typeof putWebsite>>,
  TError,
  { data: MicrohttpWebsite },
  TContext
> => {
  const mutationOptions = getPutWebsiteMutationOptions(options);

  return useMutation(mutationOptions);
};

/**
 * Delete a registered but unverified website
 * @summary Remove a website
 */
export const deleteWebsite = (
  params: DeleteWebsiteParams,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<string>> => {
  return axios.delete(`https://api.unlockpage.com/website`, {
    ...options,
    params: { ...params, ...options?.params },
  });
};

export const getDeleteWebsiteMutationOptions = <
  TError = AxiosError<string>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof deleteWebsite>>,
    TError,
    { params: DeleteWebsiteParams },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationOptions<
  Awaited<ReturnType<typeof deleteWebsite>>,
  TError,
  { params: DeleteWebsiteParams },
  TContext
> => {
  const { mutation: mutationOptions, axios: axiosOptions } = options ?? {};

  const mutationFn: MutationFunction<
    Awaited<ReturnType<typeof deleteWebsite>>,
    { params: DeleteWebsiteParams }
  > = (props) => {
    const { params } = props ?? {};

    return deleteWebsite(params, axiosOptions);
  };

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

export type DeleteWebsiteMutationResult = NonNullable<
  Awaited<ReturnType<typeof deleteWebsite>>
>;

export type DeleteWebsiteMutationError = AxiosError<string>;

/**
 * @summary Remove a website
 */
export const useDeleteWebsite = <
  TError = AxiosError<string>,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof deleteWebsite>>,
    TError,
    { params: DeleteWebsiteParams },
    TContext
  >;
  axios?: AxiosRequestConfig;
}): UseMutationResult<
  Awaited<ReturnType<typeof deleteWebsite>>,
  TError,
  { params: DeleteWebsiteParams },
  TContext
> => {
  const mutationOptions = getDeleteWebsiteMutationOptions(options);

  return useMutation(mutationOptions);
};

/**
 * Retrieve the signing key for a specific domain (owner only)
 * @summary Get domain signing key
 */
export const getWebsiteIdSigningKey = (
  id: string,
  options?: AxiosRequestConfig,
): Promise<AxiosResponse<GetWebsiteIdSigningKey200>> => {
  return axios.get(
    `https://api.unlockpage.com/website/${id}/signing-key`,
    options,
  );
};

export const getGetWebsiteIdSigningKeyQueryKey = (id: string) => {
  return [`https://api.unlockpage.com/website/${id}/signing-key`] as const;
};

export const getGetWebsiteIdSigningKeyQueryOptions = <
  TData = Awaited<ReturnType<typeof getWebsiteIdSigningKey>>,
  TError = AxiosError<string>,
>(
  id: string,
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof getWebsiteIdSigningKey>>,
        TError,
        TData
      >
    >;
    axios?: AxiosRequestConfig;
  },
) => {
  const { query: queryOptions, axios: axiosOptions } = options ?? {};

  const queryKey =
    queryOptions?.queryKey ?? getGetWebsiteIdSigningKeyQueryKey(id);

  const queryFn: QueryFunction<
    Awaited<ReturnType<typeof getWebsiteIdSigningKey>>
  > = ({ signal }) => getWebsiteIdSigningKey(id, { signal, ...axiosOptions });

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

export type GetWebsiteIdSigningKeyQueryResult = NonNullable<
  Awaited<ReturnType<typeof getWebsiteIdSigningKey>>
>;
export type GetWebsiteIdSigningKeyQueryError = AxiosError<string>;

/**
 * @summary Get domain signing key
 */
export const useGetWebsiteIdSigningKey = <
  TData = Awaited<ReturnType<typeof getWebsiteIdSigningKey>>,
  TError = AxiosError<string>,
>(
  id: string,
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof getWebsiteIdSigningKey>>,
        TError,
        TData
      >
    >;
    axios?: AxiosRequestConfig;
  },
): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
  const queryOptions = getGetWebsiteIdSigningKeyQueryOptions(id, options);

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

  query.queryKey = queryOptions.queryKey;

  return query;
};