/**
 * Generated by orval v8.2.0 🍺
 * Do not edit manually.
 * OpenClaw Agency API
 * OpenAPI spec version: 0.3.0
 */
import { useMutation, useQuery } from "@tanstack/react-query";
import type {
  DataTag,
  DefinedInitialDataOptions,
  DefinedUseQueryResult,
  MutationFunction,
  QueryClient,
  QueryFunction,
  QueryKey,
  UndefinedInitialDataOptions,
  UseMutationOptions,
  UseMutationResult,
  UseQueryOptions,
  UseQueryResult,
} from "@tanstack/react-query";

import type {
  Department,
  DepartmentCreate,
  DepartmentUpdate,
  Employee,
  EmployeeCreate,
  EmployeeUpdate,
  HTTPValidationError,
  ListTeamsTeamsGetParams,
  Team,
  TeamCreate,
  TeamUpdate,
} from ".././model";

import { customFetch } from "../../mutator";

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

/**
 * @summary List Departments
 */
export type listDepartmentsDepartmentsGetResponse200 = {
  data: Department[];
  status: 200;
};

export type listDepartmentsDepartmentsGetResponseSuccess =
  listDepartmentsDepartmentsGetResponse200 & {
    headers: Headers;
  };
export type listDepartmentsDepartmentsGetResponse =
  listDepartmentsDepartmentsGetResponseSuccess;

export const getListDepartmentsDepartmentsGetUrl = () => {
  return `/departments`;
};

export const listDepartmentsDepartmentsGet = async (
  options?: RequestInit,
): Promise<listDepartmentsDepartmentsGetResponse> => {
  return customFetch<listDepartmentsDepartmentsGetResponse>(
    getListDepartmentsDepartmentsGetUrl(),
    {
      ...options,
      method: "GET",
    },
  );
};

export const getListDepartmentsDepartmentsGetQueryKey = () => {
  return [`/departments`] as const;
};

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

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

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

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

export type ListDepartmentsDepartmentsGetQueryResult = NonNullable<
  Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>
>;
export type ListDepartmentsDepartmentsGetQueryError = unknown;

export function useListDepartmentsDepartmentsGet<
  TData = Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>,
  TError = unknown,
>(
  options: {
    query: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>,
        TError,
        TData
      >
    > &
      Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>,
          TError,
          Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>
        >,
        "initialData"
      >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): DefinedUseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
};
export function useListDepartmentsDepartmentsGet<
  TData = Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>,
  TError = unknown,
>(
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>,
        TError,
        TData
      >
    > &
      Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>,
          TError,
          Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>
        >,
        "initialData"
      >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
};
export function useListDepartmentsDepartmentsGet<
  TData = Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>,
  TError = unknown,
>(
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>,
        TError,
        TData
      >
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
};
/**
 * @summary List Departments
 */

export function useListDepartmentsDepartmentsGet<
  TData = Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>,
  TError = unknown,
>(
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listDepartmentsDepartmentsGet>>,
        TError,
        TData
      >
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
} {
  const queryOptions = getListDepartmentsDepartmentsGetQueryOptions(options);

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

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

/**
 * Create a department.

Important: keep the operation atomic. We flush to get dept.id, log the activity,
then commit once. We also translate common DB integrity errors into 409s.
 * @summary Create Department
 */
export type createDepartmentDepartmentsPostResponse200 = {
  data: Department;
  status: 200;
};

export type createDepartmentDepartmentsPostResponse422 = {
  data: HTTPValidationError;
  status: 422;
};

export type createDepartmentDepartmentsPostResponseSuccess =
  createDepartmentDepartmentsPostResponse200 & {
    headers: Headers;
  };
export type createDepartmentDepartmentsPostResponseError =
  createDepartmentDepartmentsPostResponse422 & {
    headers: Headers;
  };

export type createDepartmentDepartmentsPostResponse =
  | createDepartmentDepartmentsPostResponseSuccess
  | createDepartmentDepartmentsPostResponseError;

export const getCreateDepartmentDepartmentsPostUrl = () => {
  return `/departments`;
};

export const createDepartmentDepartmentsPost = async (
  departmentCreate: DepartmentCreate,
  options?: RequestInit,
): Promise<createDepartmentDepartmentsPostResponse> => {
  return customFetch<createDepartmentDepartmentsPostResponse>(
    getCreateDepartmentDepartmentsPostUrl(),
    {
      ...options,
      method: "POST",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(departmentCreate),
    },
  );
};

export const getCreateDepartmentDepartmentsPostMutationOptions = <
  TError = HTTPValidationError,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof createDepartmentDepartmentsPost>>,
    TError,
    { data: DepartmentCreate },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof createDepartmentDepartmentsPost>>,
  TError,
  { data: DepartmentCreate },
  TContext
> => {
  const mutationKey = ["createDepartmentDepartmentsPost"];
  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 createDepartmentDepartmentsPost>>,
    { data: DepartmentCreate }
  > = (props) => {
    const { data } = props ?? {};

    return createDepartmentDepartmentsPost(data, requestOptions);
  };

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

export type CreateDepartmentDepartmentsPostMutationResult = NonNullable<
  Awaited<ReturnType<typeof createDepartmentDepartmentsPost>>
>;
export type CreateDepartmentDepartmentsPostMutationBody = DepartmentCreate;
export type CreateDepartmentDepartmentsPostMutationError = HTTPValidationError;

/**
 * @summary Create Department
 */
export const useCreateDepartmentDepartmentsPost = <
  TError = HTTPValidationError,
  TContext = unknown,
>(
  options?: {
    mutation?: UseMutationOptions<
      Awaited<ReturnType<typeof createDepartmentDepartmentsPost>>,
      TError,
      { data: DepartmentCreate },
      TContext
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseMutationResult<
  Awaited<ReturnType<typeof createDepartmentDepartmentsPost>>,
  TError,
  { data: DepartmentCreate },
  TContext
> => {
  return useMutation(
    getCreateDepartmentDepartmentsPostMutationOptions(options),
    queryClient,
  );
};
/**
 * @summary List Teams
 */
export type listTeamsTeamsGetResponse200 = {
  data: Team[];
  status: 200;
};

export type listTeamsTeamsGetResponse422 = {
  data: HTTPValidationError;
  status: 422;
};

export type listTeamsTeamsGetResponseSuccess = listTeamsTeamsGetResponse200 & {
  headers: Headers;
};
export type listTeamsTeamsGetResponseError = listTeamsTeamsGetResponse422 & {
  headers: Headers;
};

export type listTeamsTeamsGetResponse =
  | listTeamsTeamsGetResponseSuccess
  | listTeamsTeamsGetResponseError;

export const getListTeamsTeamsGetUrl = (params?: ListTeamsTeamsGetParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `/teams?${stringifiedParams}`
    : `/teams`;
};

export const listTeamsTeamsGet = async (
  params?: ListTeamsTeamsGetParams,
  options?: RequestInit,
): Promise<listTeamsTeamsGetResponse> => {
  return customFetch<listTeamsTeamsGetResponse>(
    getListTeamsTeamsGetUrl(params),
    {
      ...options,
      method: "GET",
    },
  );
};

export const getListTeamsTeamsGetQueryKey = (
  params?: ListTeamsTeamsGetParams,
) => {
  return [`/teams`, ...(params ? [params] : [])] as const;
};

export const getListTeamsTeamsGetQueryOptions = <
  TData = Awaited<ReturnType<typeof listTeamsTeamsGet>>,
  TError = HTTPValidationError,
>(
  params?: ListTeamsTeamsGetParams,
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listTeamsTeamsGet>>,
        TError,
        TData
      >
    >;
    request?: SecondParameter<typeof customFetch>;
  },
) => {
  const { query: queryOptions, request: requestOptions } = options ?? {};

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

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

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

export type ListTeamsTeamsGetQueryResult = NonNullable<
  Awaited<ReturnType<typeof listTeamsTeamsGet>>
>;
export type ListTeamsTeamsGetQueryError = HTTPValidationError;

export function useListTeamsTeamsGet<
  TData = Awaited<ReturnType<typeof listTeamsTeamsGet>>,
  TError = HTTPValidationError,
>(
  params: undefined | ListTeamsTeamsGetParams,
  options: {
    query: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listTeamsTeamsGet>>,
        TError,
        TData
      >
    > &
      Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof listTeamsTeamsGet>>,
          TError,
          Awaited<ReturnType<typeof listTeamsTeamsGet>>
        >,
        "initialData"
      >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): DefinedUseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
};
export function useListTeamsTeamsGet<
  TData = Awaited<ReturnType<typeof listTeamsTeamsGet>>,
  TError = HTTPValidationError,
>(
  params?: ListTeamsTeamsGetParams,
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listTeamsTeamsGet>>,
        TError,
        TData
      >
    > &
      Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof listTeamsTeamsGet>>,
          TError,
          Awaited<ReturnType<typeof listTeamsTeamsGet>>
        >,
        "initialData"
      >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
};
export function useListTeamsTeamsGet<
  TData = Awaited<ReturnType<typeof listTeamsTeamsGet>>,
  TError = HTTPValidationError,
>(
  params?: ListTeamsTeamsGetParams,
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listTeamsTeamsGet>>,
        TError,
        TData
      >
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
};
/**
 * @summary List Teams
 */

export function useListTeamsTeamsGet<
  TData = Awaited<ReturnType<typeof listTeamsTeamsGet>>,
  TError = HTTPValidationError,
>(
  params?: ListTeamsTeamsGetParams,
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listTeamsTeamsGet>>,
        TError,
        TData
      >
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
} {
  const queryOptions = getListTeamsTeamsGetQueryOptions(params, options);

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

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

/**
 * @summary Create Team
 */
export type createTeamTeamsPostResponse200 = {
  data: Team;
  status: 200;
};

export type createTeamTeamsPostResponse422 = {
  data: HTTPValidationError;
  status: 422;
};

export type createTeamTeamsPostResponseSuccess =
  createTeamTeamsPostResponse200 & {
    headers: Headers;
  };
export type createTeamTeamsPostResponseError =
  createTeamTeamsPostResponse422 & {
    headers: Headers;
  };

export type createTeamTeamsPostResponse =
  | createTeamTeamsPostResponseSuccess
  | createTeamTeamsPostResponseError;

export const getCreateTeamTeamsPostUrl = () => {
  return `/teams`;
};

export const createTeamTeamsPost = async (
  teamCreate: TeamCreate,
  options?: RequestInit,
): Promise<createTeamTeamsPostResponse> => {
  return customFetch<createTeamTeamsPostResponse>(getCreateTeamTeamsPostUrl(), {
    ...options,
    method: "POST",
    headers: { "Content-Type": "application/json", ...options?.headers },
    body: JSON.stringify(teamCreate),
  });
};

export const getCreateTeamTeamsPostMutationOptions = <
  TError = HTTPValidationError,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof createTeamTeamsPost>>,
    TError,
    { data: TeamCreate },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof createTeamTeamsPost>>,
  TError,
  { data: TeamCreate },
  TContext
> => {
  const mutationKey = ["createTeamTeamsPost"];
  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 createTeamTeamsPost>>,
    { data: TeamCreate }
  > = (props) => {
    const { data } = props ?? {};

    return createTeamTeamsPost(data, requestOptions);
  };

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

export type CreateTeamTeamsPostMutationResult = NonNullable<
  Awaited<ReturnType<typeof createTeamTeamsPost>>
>;
export type CreateTeamTeamsPostMutationBody = TeamCreate;
export type CreateTeamTeamsPostMutationError = HTTPValidationError;

/**
 * @summary Create Team
 */
export const useCreateTeamTeamsPost = <
  TError = HTTPValidationError,
  TContext = unknown,
>(
  options?: {
    mutation?: UseMutationOptions<
      Awaited<ReturnType<typeof createTeamTeamsPost>>,
      TError,
      { data: TeamCreate },
      TContext
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseMutationResult<
  Awaited<ReturnType<typeof createTeamTeamsPost>>,
  TError,
  { data: TeamCreate },
  TContext
> => {
  return useMutation(
    getCreateTeamTeamsPostMutationOptions(options),
    queryClient,
  );
};
/**
 * @summary Update Team
 */
export type updateTeamTeamsTeamIdPatchResponse200 = {
  data: Team;
  status: 200;
};

export type updateTeamTeamsTeamIdPatchResponse422 = {
  data: HTTPValidationError;
  status: 422;
};

export type updateTeamTeamsTeamIdPatchResponseSuccess =
  updateTeamTeamsTeamIdPatchResponse200 & {
    headers: Headers;
  };
export type updateTeamTeamsTeamIdPatchResponseError =
  updateTeamTeamsTeamIdPatchResponse422 & {
    headers: Headers;
  };

export type updateTeamTeamsTeamIdPatchResponse =
  | updateTeamTeamsTeamIdPatchResponseSuccess
  | updateTeamTeamsTeamIdPatchResponseError;

export const getUpdateTeamTeamsTeamIdPatchUrl = (teamId: number) => {
  return `/teams/${teamId}`;
};

export const updateTeamTeamsTeamIdPatch = async (
  teamId: number,
  teamUpdate: TeamUpdate,
  options?: RequestInit,
): Promise<updateTeamTeamsTeamIdPatchResponse> => {
  return customFetch<updateTeamTeamsTeamIdPatchResponse>(
    getUpdateTeamTeamsTeamIdPatchUrl(teamId),
    {
      ...options,
      method: "PATCH",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(teamUpdate),
    },
  );
};

export const getUpdateTeamTeamsTeamIdPatchMutationOptions = <
  TError = HTTPValidationError,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof updateTeamTeamsTeamIdPatch>>,
    TError,
    { teamId: number; data: TeamUpdate },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof updateTeamTeamsTeamIdPatch>>,
  TError,
  { teamId: number; data: TeamUpdate },
  TContext
> => {
  const mutationKey = ["updateTeamTeamsTeamIdPatch"];
  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 updateTeamTeamsTeamIdPatch>>,
    { teamId: number; data: TeamUpdate }
  > = (props) => {
    const { teamId, data } = props ?? {};

    return updateTeamTeamsTeamIdPatch(teamId, data, requestOptions);
  };

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

export type UpdateTeamTeamsTeamIdPatchMutationResult = NonNullable<
  Awaited<ReturnType<typeof updateTeamTeamsTeamIdPatch>>
>;
export type UpdateTeamTeamsTeamIdPatchMutationBody = TeamUpdate;
export type UpdateTeamTeamsTeamIdPatchMutationError = HTTPValidationError;

/**
 * @summary Update Team
 */
export const useUpdateTeamTeamsTeamIdPatch = <
  TError = HTTPValidationError,
  TContext = unknown,
>(
  options?: {
    mutation?: UseMutationOptions<
      Awaited<ReturnType<typeof updateTeamTeamsTeamIdPatch>>,
      TError,
      { teamId: number; data: TeamUpdate },
      TContext
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseMutationResult<
  Awaited<ReturnType<typeof updateTeamTeamsTeamIdPatch>>,
  TError,
  { teamId: number; data: TeamUpdate },
  TContext
> => {
  return useMutation(
    getUpdateTeamTeamsTeamIdPatchMutationOptions(options),
    queryClient,
  );
};
/**
 * @summary Update Department
 */
export type updateDepartmentDepartmentsDepartmentIdPatchResponse200 = {
  data: Department;
  status: 200;
};

export type updateDepartmentDepartmentsDepartmentIdPatchResponse422 = {
  data: HTTPValidationError;
  status: 422;
};

export type updateDepartmentDepartmentsDepartmentIdPatchResponseSuccess =
  updateDepartmentDepartmentsDepartmentIdPatchResponse200 & {
    headers: Headers;
  };
export type updateDepartmentDepartmentsDepartmentIdPatchResponseError =
  updateDepartmentDepartmentsDepartmentIdPatchResponse422 & {
    headers: Headers;
  };

export type updateDepartmentDepartmentsDepartmentIdPatchResponse =
  | updateDepartmentDepartmentsDepartmentIdPatchResponseSuccess
  | updateDepartmentDepartmentsDepartmentIdPatchResponseError;

export const getUpdateDepartmentDepartmentsDepartmentIdPatchUrl = (
  departmentId: number,
) => {
  return `/departments/${departmentId}`;
};

export const updateDepartmentDepartmentsDepartmentIdPatch = async (
  departmentId: number,
  departmentUpdate: DepartmentUpdate,
  options?: RequestInit,
): Promise<updateDepartmentDepartmentsDepartmentIdPatchResponse> => {
  return customFetch<updateDepartmentDepartmentsDepartmentIdPatchResponse>(
    getUpdateDepartmentDepartmentsDepartmentIdPatchUrl(departmentId),
    {
      ...options,
      method: "PATCH",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(departmentUpdate),
    },
  );
};

export const getUpdateDepartmentDepartmentsDepartmentIdPatchMutationOptions = <
  TError = HTTPValidationError,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof updateDepartmentDepartmentsDepartmentIdPatch>>,
    TError,
    { departmentId: number; data: DepartmentUpdate },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof updateDepartmentDepartmentsDepartmentIdPatch>>,
  TError,
  { departmentId: number; data: DepartmentUpdate },
  TContext
> => {
  const mutationKey = ["updateDepartmentDepartmentsDepartmentIdPatch"];
  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 updateDepartmentDepartmentsDepartmentIdPatch>>,
    { departmentId: number; data: DepartmentUpdate }
  > = (props) => {
    const { departmentId, data } = props ?? {};

    return updateDepartmentDepartmentsDepartmentIdPatch(
      departmentId,
      data,
      requestOptions,
    );
  };

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

export type UpdateDepartmentDepartmentsDepartmentIdPatchMutationResult =
  NonNullable<
    Awaited<ReturnType<typeof updateDepartmentDepartmentsDepartmentIdPatch>>
  >;
export type UpdateDepartmentDepartmentsDepartmentIdPatchMutationBody =
  DepartmentUpdate;
export type UpdateDepartmentDepartmentsDepartmentIdPatchMutationError =
  HTTPValidationError;

/**
 * @summary Update Department
 */
export const useUpdateDepartmentDepartmentsDepartmentIdPatch = <
  TError = HTTPValidationError,
  TContext = unknown,
>(
  options?: {
    mutation?: UseMutationOptions<
      Awaited<ReturnType<typeof updateDepartmentDepartmentsDepartmentIdPatch>>,
      TError,
      { departmentId: number; data: DepartmentUpdate },
      TContext
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseMutationResult<
  Awaited<ReturnType<typeof updateDepartmentDepartmentsDepartmentIdPatch>>,
  TError,
  { departmentId: number; data: DepartmentUpdate },
  TContext
> => {
  return useMutation(
    getUpdateDepartmentDepartmentsDepartmentIdPatchMutationOptions(options),
    queryClient,
  );
};
/**
 * @summary List Employees
 */
export type listEmployeesEmployeesGetResponse200 = {
  data: Employee[];
  status: 200;
};

export type listEmployeesEmployeesGetResponseSuccess =
  listEmployeesEmployeesGetResponse200 & {
    headers: Headers;
  };
export type listEmployeesEmployeesGetResponse =
  listEmployeesEmployeesGetResponseSuccess;

export const getListEmployeesEmployeesGetUrl = () => {
  return `/employees`;
};

export const listEmployeesEmployeesGet = async (
  options?: RequestInit,
): Promise<listEmployeesEmployeesGetResponse> => {
  return customFetch<listEmployeesEmployeesGetResponse>(
    getListEmployeesEmployeesGetUrl(),
    {
      ...options,
      method: "GET",
    },
  );
};

export const getListEmployeesEmployeesGetQueryKey = () => {
  return [`/employees`] as const;
};

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

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

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

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

export type ListEmployeesEmployeesGetQueryResult = NonNullable<
  Awaited<ReturnType<typeof listEmployeesEmployeesGet>>
>;
export type ListEmployeesEmployeesGetQueryError = unknown;

export function useListEmployeesEmployeesGet<
  TData = Awaited<ReturnType<typeof listEmployeesEmployeesGet>>,
  TError = unknown,
>(
  options: {
    query: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listEmployeesEmployeesGet>>,
        TError,
        TData
      >
    > &
      Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof listEmployeesEmployeesGet>>,
          TError,
          Awaited<ReturnType<typeof listEmployeesEmployeesGet>>
        >,
        "initialData"
      >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): DefinedUseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
};
export function useListEmployeesEmployeesGet<
  TData = Awaited<ReturnType<typeof listEmployeesEmployeesGet>>,
  TError = unknown,
>(
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listEmployeesEmployeesGet>>,
        TError,
        TData
      >
    > &
      Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof listEmployeesEmployeesGet>>,
          TError,
          Awaited<ReturnType<typeof listEmployeesEmployeesGet>>
        >,
        "initialData"
      >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
};
export function useListEmployeesEmployeesGet<
  TData = Awaited<ReturnType<typeof listEmployeesEmployeesGet>>,
  TError = unknown,
>(
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listEmployeesEmployeesGet>>,
        TError,
        TData
      >
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
};
/**
 * @summary List Employees
 */

export function useListEmployeesEmployeesGet<
  TData = Awaited<ReturnType<typeof listEmployeesEmployeesGet>>,
  TError = unknown,
>(
  options?: {
    query?: Partial<
      UseQueryOptions<
        Awaited<ReturnType<typeof listEmployeesEmployeesGet>>,
        TError,
        TData
      >
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
  queryKey: DataTag<QueryKey, TData, TError>;
} {
  const queryOptions = getListEmployeesEmployeesGetQueryOptions(options);

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

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

/**
 * @summary Create Employee
 */
export type createEmployeeEmployeesPostResponse200 = {
  data: Employee;
  status: 200;
};

export type createEmployeeEmployeesPostResponse422 = {
  data: HTTPValidationError;
  status: 422;
};

export type createEmployeeEmployeesPostResponseSuccess =
  createEmployeeEmployeesPostResponse200 & {
    headers: Headers;
  };
export type createEmployeeEmployeesPostResponseError =
  createEmployeeEmployeesPostResponse422 & {
    headers: Headers;
  };

export type createEmployeeEmployeesPostResponse =
  | createEmployeeEmployeesPostResponseSuccess
  | createEmployeeEmployeesPostResponseError;

export const getCreateEmployeeEmployeesPostUrl = () => {
  return `/employees`;
};

export const createEmployeeEmployeesPost = async (
  employeeCreate: EmployeeCreate,
  options?: RequestInit,
): Promise<createEmployeeEmployeesPostResponse> => {
  return customFetch<createEmployeeEmployeesPostResponse>(
    getCreateEmployeeEmployeesPostUrl(),
    {
      ...options,
      method: "POST",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(employeeCreate),
    },
  );
};

export const getCreateEmployeeEmployeesPostMutationOptions = <
  TError = HTTPValidationError,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof createEmployeeEmployeesPost>>,
    TError,
    { data: EmployeeCreate },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof createEmployeeEmployeesPost>>,
  TError,
  { data: EmployeeCreate },
  TContext
> => {
  const mutationKey = ["createEmployeeEmployeesPost"];
  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 createEmployeeEmployeesPost>>,
    { data: EmployeeCreate }
  > = (props) => {
    const { data } = props ?? {};

    return createEmployeeEmployeesPost(data, requestOptions);
  };

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

export type CreateEmployeeEmployeesPostMutationResult = NonNullable<
  Awaited<ReturnType<typeof createEmployeeEmployeesPost>>
>;
export type CreateEmployeeEmployeesPostMutationBody = EmployeeCreate;
export type CreateEmployeeEmployeesPostMutationError = HTTPValidationError;

/**
 * @summary Create Employee
 */
export const useCreateEmployeeEmployeesPost = <
  TError = HTTPValidationError,
  TContext = unknown,
>(
  options?: {
    mutation?: UseMutationOptions<
      Awaited<ReturnType<typeof createEmployeeEmployeesPost>>,
      TError,
      { data: EmployeeCreate },
      TContext
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseMutationResult<
  Awaited<ReturnType<typeof createEmployeeEmployeesPost>>,
  TError,
  { data: EmployeeCreate },
  TContext
> => {
  return useMutation(
    getCreateEmployeeEmployeesPostMutationOptions(options),
    queryClient,
  );
};
/**
 * @summary Update Employee
 */
export type updateEmployeeEmployeesEmployeeIdPatchResponse200 = {
  data: Employee;
  status: 200;
};

export type updateEmployeeEmployeesEmployeeIdPatchResponse422 = {
  data: HTTPValidationError;
  status: 422;
};

export type updateEmployeeEmployeesEmployeeIdPatchResponseSuccess =
  updateEmployeeEmployeesEmployeeIdPatchResponse200 & {
    headers: Headers;
  };
export type updateEmployeeEmployeesEmployeeIdPatchResponseError =
  updateEmployeeEmployeesEmployeeIdPatchResponse422 & {
    headers: Headers;
  };

export type updateEmployeeEmployeesEmployeeIdPatchResponse =
  | updateEmployeeEmployeesEmployeeIdPatchResponseSuccess
  | updateEmployeeEmployeesEmployeeIdPatchResponseError;

export const getUpdateEmployeeEmployeesEmployeeIdPatchUrl = (
  employeeId: number,
) => {
  return `/employees/${employeeId}`;
};

export const updateEmployeeEmployeesEmployeeIdPatch = async (
  employeeId: number,
  employeeUpdate: EmployeeUpdate,
  options?: RequestInit,
): Promise<updateEmployeeEmployeesEmployeeIdPatchResponse> => {
  return customFetch<updateEmployeeEmployeesEmployeeIdPatchResponse>(
    getUpdateEmployeeEmployeesEmployeeIdPatchUrl(employeeId),
    {
      ...options,
      method: "PATCH",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(employeeUpdate),
    },
  );
};

export const getUpdateEmployeeEmployeesEmployeeIdPatchMutationOptions = <
  TError = HTTPValidationError,
  TContext = unknown,
>(options?: {
  mutation?: UseMutationOptions<
    Awaited<ReturnType<typeof updateEmployeeEmployeesEmployeeIdPatch>>,
    TError,
    { employeeId: number; data: EmployeeUpdate },
    TContext
  >;
  request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
  Awaited<ReturnType<typeof updateEmployeeEmployeesEmployeeIdPatch>>,
  TError,
  { employeeId: number; data: EmployeeUpdate },
  TContext
> => {
  const mutationKey = ["updateEmployeeEmployeesEmployeeIdPatch"];
  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 updateEmployeeEmployeesEmployeeIdPatch>>,
    { employeeId: number; data: EmployeeUpdate }
  > = (props) => {
    const { employeeId, data } = props ?? {};

    return updateEmployeeEmployeesEmployeeIdPatch(
      employeeId,
      data,
      requestOptions,
    );
  };

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

export type UpdateEmployeeEmployeesEmployeeIdPatchMutationResult = NonNullable<
  Awaited<ReturnType<typeof updateEmployeeEmployeesEmployeeIdPatch>>
>;
export type UpdateEmployeeEmployeesEmployeeIdPatchMutationBody = EmployeeUpdate;
export type UpdateEmployeeEmployeesEmployeeIdPatchMutationError =
  HTTPValidationError;

/**
 * @summary Update Employee
 */
export const useUpdateEmployeeEmployeesEmployeeIdPatch = <
  TError = HTTPValidationError,
  TContext = unknown,
>(
  options?: {
    mutation?: UseMutationOptions<
      Awaited<ReturnType<typeof updateEmployeeEmployeesEmployeeIdPatch>>,
      TError,
      { employeeId: number; data: EmployeeUpdate },
      TContext
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseMutationResult<
  Awaited<ReturnType<typeof updateEmployeeEmployeesEmployeeIdPatch>>,
  TError,
  { employeeId: number; data: EmployeeUpdate },
  TContext
> => {
  return useMutation(
    getUpdateEmployeeEmployeesEmployeeIdPatchMutationOptions(options),
    queryClient,
  );
};
/**
 * @summary Provision Employee Agent
 */
export type provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponse200 =
  {
    data: Employee;
    status: 200;
  };

export type provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponse422 =
  {
    data: HTTPValidationError;
    status: 422;
  };

export type provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponseSuccess =
  provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponse200 & {
    headers: Headers;
  };
export type provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponseError =
  provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponse422 & {
    headers: Headers;
  };

export type provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponse =
  | provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponseSuccess
  | provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponseError;

export const getProvisionEmployeeAgentEmployeesEmployeeIdProvisionPostUrl = (
  employeeId: number,
) => {
  return `/employees/${employeeId}/provision`;
};

export const provisionEmployeeAgentEmployeesEmployeeIdProvisionPost = async (
  employeeId: number,
  options?: RequestInit,
): Promise<provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponse> => {
  return customFetch<provisionEmployeeAgentEmployeesEmployeeIdProvisionPostResponse>(
    getProvisionEmployeeAgentEmployeesEmployeeIdProvisionPostUrl(employeeId),
    {
      ...options,
      method: "POST",
    },
  );
};

export const getProvisionEmployeeAgentEmployeesEmployeeIdProvisionPostMutationOptions =
  <TError = HTTPValidationError, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<
      Awaited<
        ReturnType<
          typeof provisionEmployeeAgentEmployeesEmployeeIdProvisionPost
        >
      >,
      TError,
      { employeeId: number },
      TContext
    >;
    request?: SecondParameter<typeof customFetch>;
  }): UseMutationOptions<
    Awaited<
      ReturnType<typeof provisionEmployeeAgentEmployeesEmployeeIdProvisionPost>
    >,
    TError,
    { employeeId: number },
    TContext
  > => {
    const mutationKey = [
      "provisionEmployeeAgentEmployeesEmployeeIdProvisionPost",
    ];
    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 provisionEmployeeAgentEmployeesEmployeeIdProvisionPost
        >
      >,
      { employeeId: number }
    > = (props) => {
      const { employeeId } = props ?? {};

      return provisionEmployeeAgentEmployeesEmployeeIdProvisionPost(
        employeeId,
        requestOptions,
      );
    };

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

export type ProvisionEmployeeAgentEmployeesEmployeeIdProvisionPostMutationResult =
  NonNullable<
    Awaited<
      ReturnType<typeof provisionEmployeeAgentEmployeesEmployeeIdProvisionPost>
    >
  >;

export type ProvisionEmployeeAgentEmployeesEmployeeIdProvisionPostMutationError =
  HTTPValidationError;

/**
 * @summary Provision Employee Agent
 */
export const useProvisionEmployeeAgentEmployeesEmployeeIdProvisionPost = <
  TError = HTTPValidationError,
  TContext = unknown,
>(
  options?: {
    mutation?: UseMutationOptions<
      Awaited<
        ReturnType<
          typeof provisionEmployeeAgentEmployeesEmployeeIdProvisionPost
        >
      >,
      TError,
      { employeeId: number },
      TContext
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseMutationResult<
  Awaited<
    ReturnType<typeof provisionEmployeeAgentEmployeesEmployeeIdProvisionPost>
  >,
  TError,
  { employeeId: number },
  TContext
> => {
  return useMutation(
    getProvisionEmployeeAgentEmployeesEmployeeIdProvisionPostMutationOptions(
      options,
    ),
    queryClient,
  );
};
/**
 * @summary Deprovision Employee Agent
 */
export type deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponse200 =
  {
    data: Employee;
    status: 200;
  };

export type deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponse422 =
  {
    data: HTTPValidationError;
    status: 422;
  };

export type deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponseSuccess =
  deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponse200 & {
    headers: Headers;
  };
export type deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponseError =
  deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponse422 & {
    headers: Headers;
  };

export type deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponse =
  | deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponseSuccess
  | deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponseError;

export const getDeprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostUrl =
  (employeeId: number) => {
    return `/employees/${employeeId}/deprovision`;
  };

export const deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPost =
  async (
    employeeId: number,
    options?: RequestInit,
  ): Promise<deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponse> => {
    return customFetch<deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostResponse>(
      getDeprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostUrl(
        employeeId,
      ),
      {
        ...options,
        method: "POST",
      },
    );
  };

export const getDeprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostMutationOptions =
  <TError = HTTPValidationError, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<
      Awaited<
        ReturnType<
          typeof deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPost
        >
      >,
      TError,
      { employeeId: number },
      TContext
    >;
    request?: SecondParameter<typeof customFetch>;
  }): UseMutationOptions<
    Awaited<
      ReturnType<
        typeof deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPost
      >
    >,
    TError,
    { employeeId: number },
    TContext
  > => {
    const mutationKey = [
      "deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPost",
    ];
    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 deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPost
        >
      >,
      { employeeId: number }
    > = (props) => {
      const { employeeId } = props ?? {};

      return deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPost(
        employeeId,
        requestOptions,
      );
    };

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

export type DeprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostMutationResult =
  NonNullable<
    Awaited<
      ReturnType<
        typeof deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPost
      >
    >
  >;

export type DeprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostMutationError =
  HTTPValidationError;

/**
 * @summary Deprovision Employee Agent
 */
export const useDeprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPost = <
  TError = HTTPValidationError,
  TContext = unknown,
>(
  options?: {
    mutation?: UseMutationOptions<
      Awaited<
        ReturnType<
          typeof deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPost
        >
      >,
      TError,
      { employeeId: number },
      TContext
    >;
    request?: SecondParameter<typeof customFetch>;
  },
  queryClient?: QueryClient,
): UseMutationResult<
  Awaited<
    ReturnType<
      typeof deprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPost
    >
  >,
  TError,
  { employeeId: number },
  TContext
> => {
  return useMutation(
    getDeprovisionEmployeeAgentEmployeesEmployeeIdDeprovisionPostMutationOptions(
      options,
    ),
    queryClient,
  );
};