/**
 * Generated by orval v8.9.1 🍺
 * Do not edit manually.
 * Api
 * BookWithNesto shortlet apartment platform 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 {
  Apartment,
  ApartmentInput,
  ApartmentUpdate,
  AvailabilityUpdate,
  BlogPost,
  BlogPostInput,
  BlogPostUpdate,
  BookedDateRange,
  Booking,
  BookingInput,
  BookingStatusUpdate,
  ChatMessage,
  ChatMessageInput,
  CityCount,
  CityStats,
  ContactInput,
  ContactStatusUpdate,
  ContactSubmission,
  DashboardStats,
  GalleryImage,
  GalleryImageInput,
  HealthStatus,
  ListApartmentsParams,
  ListBlogPostsParams,
  ListChatMessagesParams,
  ListGalleryImagesParams,
  ListServicePackagesParams,
  NewsletterInput,
  NewsletterSubscriber,
  Review,
  ReviewInput,
  ServicePackage,
  ServicePackageUpdate
} 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];



export const getHealthCheckUrl = () => {




  return `/api/healthz`
}

/**
 * @summary Health check
 */
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 };
}







export const getListApartmentsUrl = (params?: ListApartmentsParams,) => {
  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 ? `/api/apartments?${stringifiedParams}` : `/api/apartments`
}

/**
 * @summary List apartments with optional filters
 */
export const listApartments = async (params?: ListApartmentsParams, options?: RequestInit): Promise<Apartment[]> => {

  return customFetch<Apartment[]>(getListApartmentsUrl(params),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListApartmentsQueryKey = (params?: ListApartmentsParams,) => {
    return [
    `/api/apartments`, ...(params ? [params] : [])
    ] as const;
    }


export const getListApartmentsQueryOptions = <TData = Awaited<ReturnType<typeof listApartments>>, TError = ErrorType<unknown>>(params?: ListApartmentsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listApartments>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListApartmentsQueryResult = NonNullable<Awaited<ReturnType<typeof listApartments>>>
export type ListApartmentsQueryError = ErrorType<unknown>


/**
 * @summary List apartments with optional filters
 */

export function useListApartments<TData = Awaited<ReturnType<typeof listApartments>>, TError = ErrorType<unknown>>(
 params?: ListApartmentsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listApartments>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListApartmentsQueryOptions(params,options)

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

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







export const getCreateApartmentUrl = () => {




  return `/api/apartments`
}

/**
 * @summary Create a new apartment listing (admin)
 */
export const createApartment = async (apartmentInput: ApartmentInput, options?: RequestInit): Promise<Apartment> => {

  return customFetch<Apartment>(getCreateApartmentUrl(),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      apartmentInput,)
  }
);}




export const getCreateApartmentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createApartment>>, TError,{data: BodyType<ApartmentInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createApartment>>, TError,{data: BodyType<ApartmentInput>}, TContext> => {

const mutationKey = ['createApartment'];
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 createApartment>>, {data: BodyType<ApartmentInput>}> = (props) => {
          const {data} = props ?? {};

          return  createApartment(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateApartmentMutationResult = NonNullable<Awaited<ReturnType<typeof createApartment>>>
    export type CreateApartmentMutationBody = BodyType<ApartmentInput>
    export type CreateApartmentMutationError = ErrorType<unknown>

    /**
 * @summary Create a new apartment listing (admin)
 */
export const useCreateApartment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createApartment>>, TError,{data: BodyType<ApartmentInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createApartment>>,
        TError,
        {data: BodyType<ApartmentInput>},
        TContext
      > => {
      return useMutation(getCreateApartmentMutationOptions(options));
    }

export const getListFeaturedApartmentsUrl = () => {




  return `/api/apartments/featured`
}

/**
 * @summary Get featured/highlighted apartments for homepage
 */
export const listFeaturedApartments = async ( options?: RequestInit): Promise<Apartment[]> => {

  return customFetch<Apartment[]>(getListFeaturedApartmentsUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListFeaturedApartmentsQueryKey = () => {
    return [
    `/api/apartments/featured`
    ] as const;
    }


export const getListFeaturedApartmentsQueryOptions = <TData = Awaited<ReturnType<typeof listFeaturedApartments>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listFeaturedApartments>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListFeaturedApartmentsQueryResult = NonNullable<Awaited<ReturnType<typeof listFeaturedApartments>>>
export type ListFeaturedApartmentsQueryError = ErrorType<unknown>


/**
 * @summary Get featured/highlighted apartments for homepage
 */

export function useListFeaturedApartments<TData = Awaited<ReturnType<typeof listFeaturedApartments>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listFeaturedApartments>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListFeaturedApartmentsQueryOptions(options)

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

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







export const getListCitiesUrl = () => {




  return `/api/apartments/cities`
}

/**
 * @summary Get list of cities with apartment counts
 */
export const listCities = async ( options?: RequestInit): Promise<CityCount[]> => {

  return customFetch<CityCount[]>(getListCitiesUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListCitiesQueryKey = () => {
    return [
    `/api/apartments/cities`
    ] as const;
    }


export const getListCitiesQueryOptions = <TData = Awaited<ReturnType<typeof listCities>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listCities>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListCitiesQueryResult = NonNullable<Awaited<ReturnType<typeof listCities>>>
export type ListCitiesQueryError = ErrorType<unknown>


/**
 * @summary Get list of cities with apartment counts
 */

export function useListCities<TData = Awaited<ReturnType<typeof listCities>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listCities>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListCitiesQueryOptions(options)

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

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







export const getGetApartmentUrl = (id: number,) => {




  return `/api/apartments/${id}`
}

/**
 * @summary Get apartment detail
 */
export const getApartment = async (id: number, options?: RequestInit): Promise<Apartment> => {

  return customFetch<Apartment>(getGetApartmentUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetApartmentQueryKey = (id: number,) => {
    return [
    `/api/apartments/${id}`
    ] as const;
    }


export const getGetApartmentQueryOptions = <TData = Awaited<ReturnType<typeof getApartment>>, TError = ErrorType<void>>(id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getApartment>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type GetApartmentQueryResult = NonNullable<Awaited<ReturnType<typeof getApartment>>>
export type GetApartmentQueryError = ErrorType<void>


/**
 * @summary Get apartment detail
 */

export function useGetApartment<TData = Awaited<ReturnType<typeof getApartment>>, TError = ErrorType<void>>(
 id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getApartment>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getGetApartmentQueryOptions(id,options)

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

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







export const getUpdateApartmentUrl = (id: number,) => {




  return `/api/apartments/${id}`
}

/**
 * @summary Update apartment (admin)
 */
export const updateApartment = async (id: number,
    apartmentUpdate: ApartmentUpdate, options?: RequestInit): Promise<Apartment> => {

  return customFetch<Apartment>(getUpdateApartmentUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      apartmentUpdate,)
  }
);}




export const getUpdateApartmentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateApartment>>, TError,{id: number;data: BodyType<ApartmentUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateApartment>>, TError,{id: number;data: BodyType<ApartmentUpdate>}, TContext> => {

const mutationKey = ['updateApartment'];
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 updateApartment>>, {id: number;data: BodyType<ApartmentUpdate>}> = (props) => {
          const {id,data} = props ?? {};

          return  updateApartment(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateApartmentMutationResult = NonNullable<Awaited<ReturnType<typeof updateApartment>>>
    export type UpdateApartmentMutationBody = BodyType<ApartmentUpdate>
    export type UpdateApartmentMutationError = ErrorType<unknown>

    /**
 * @summary Update apartment (admin)
 */
export const useUpdateApartment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateApartment>>, TError,{id: number;data: BodyType<ApartmentUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateApartment>>,
        TError,
        {id: number;data: BodyType<ApartmentUpdate>},
        TContext
      > => {
      return useMutation(getUpdateApartmentMutationOptions(options));
    }

export const getDeleteApartmentUrl = (id: number,) => {




  return `/api/apartments/${id}`
}

/**
 * @summary Delete apartment (admin)
 */
export const deleteApartment = async (id: number, options?: RequestInit): Promise<void> => {

  return customFetch<void>(getDeleteApartmentUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}




export const getDeleteApartmentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteApartment>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteApartment>>, TError,{id: number}, TContext> => {

const mutationKey = ['deleteApartment'];
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 deleteApartment>>, {id: number}> = (props) => {
          const {id} = props ?? {};

          return  deleteApartment(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteApartmentMutationResult = NonNullable<Awaited<ReturnType<typeof deleteApartment>>>

    export type DeleteApartmentMutationError = ErrorType<unknown>

    /**
 * @summary Delete apartment (admin)
 */
export const useDeleteApartment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteApartment>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteApartment>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeleteApartmentMutationOptions(options));
    }

export const getGetApartmentAvailabilityUrl = (id: number,) => {




  return `/api/apartments/${id}/availability`
}

/**
 * @summary Get booked date ranges for an apartment
 */
export const getApartmentAvailability = async (id: number, options?: RequestInit): Promise<BookedDateRange[]> => {

  return customFetch<BookedDateRange[]>(getGetApartmentAvailabilityUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetApartmentAvailabilityQueryKey = (id: number,) => {
    return [
    `/api/apartments/${id}/availability`
    ] as const;
    }


export const getGetApartmentAvailabilityQueryOptions = <TData = Awaited<ReturnType<typeof getApartmentAvailability>>, TError = ErrorType<unknown>>(id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getApartmentAvailability>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type GetApartmentAvailabilityQueryResult = NonNullable<Awaited<ReturnType<typeof getApartmentAvailability>>>
export type GetApartmentAvailabilityQueryError = ErrorType<unknown>


/**
 * @summary Get booked date ranges for an apartment
 */

export function useGetApartmentAvailability<TData = Awaited<ReturnType<typeof getApartmentAvailability>>, TError = ErrorType<unknown>>(
 id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getApartmentAvailability>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getGetApartmentAvailabilityQueryOptions(id,options)

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

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







export const getUpdateApartmentAvailabilityUrl = (id: number,) => {




  return `/api/apartments/${id}/availability`
}

/**
 * @summary Toggle apartment availability (admin)
 */
export const updateApartmentAvailability = async (id: number,
    availabilityUpdate: AvailabilityUpdate, options?: RequestInit): Promise<Apartment> => {

  return customFetch<Apartment>(getUpdateApartmentAvailabilityUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      availabilityUpdate,)
  }
);}




export const getUpdateApartmentAvailabilityMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateApartmentAvailability>>, TError,{id: number;data: BodyType<AvailabilityUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateApartmentAvailability>>, TError,{id: number;data: BodyType<AvailabilityUpdate>}, TContext> => {

const mutationKey = ['updateApartmentAvailability'];
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 updateApartmentAvailability>>, {id: number;data: BodyType<AvailabilityUpdate>}> = (props) => {
          const {id,data} = props ?? {};

          return  updateApartmentAvailability(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateApartmentAvailabilityMutationResult = NonNullable<Awaited<ReturnType<typeof updateApartmentAvailability>>>
    export type UpdateApartmentAvailabilityMutationBody = BodyType<AvailabilityUpdate>
    export type UpdateApartmentAvailabilityMutationError = ErrorType<unknown>

    /**
 * @summary Toggle apartment availability (admin)
 */
export const useUpdateApartmentAvailability = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateApartmentAvailability>>, TError,{id: number;data: BodyType<AvailabilityUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateApartmentAvailability>>,
        TError,
        {id: number;data: BodyType<AvailabilityUpdate>},
        TContext
      > => {
      return useMutation(getUpdateApartmentAvailabilityMutationOptions(options));
    }

export const getListApartmentReviewsUrl = (id: number,) => {




  return `/api/apartments/${id}/reviews`
}

/**
 * @summary Get reviews for an apartment
 */
export const listApartmentReviews = async (id: number, options?: RequestInit): Promise<Review[]> => {

  return customFetch<Review[]>(getListApartmentReviewsUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListApartmentReviewsQueryKey = (id: number,) => {
    return [
    `/api/apartments/${id}/reviews`
    ] as const;
    }


export const getListApartmentReviewsQueryOptions = <TData = Awaited<ReturnType<typeof listApartmentReviews>>, TError = ErrorType<unknown>>(id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listApartmentReviews>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListApartmentReviewsQueryResult = NonNullable<Awaited<ReturnType<typeof listApartmentReviews>>>
export type ListApartmentReviewsQueryError = ErrorType<unknown>


/**
 * @summary Get reviews for an apartment
 */

export function useListApartmentReviews<TData = Awaited<ReturnType<typeof listApartmentReviews>>, TError = ErrorType<unknown>>(
 id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listApartmentReviews>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListApartmentReviewsQueryOptions(id,options)

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

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







export const getCreateReviewUrl = (id: number,) => {




  return `/api/apartments/${id}/reviews`
}

/**
 * @summary Submit a review
 */
export const createReview = async (id: number,
    reviewInput: ReviewInput, options?: RequestInit): Promise<Review> => {

  return customFetch<Review>(getCreateReviewUrl(id),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      reviewInput,)
  }
);}




export const getCreateReviewMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createReview>>, TError,{id: number;data: BodyType<ReviewInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createReview>>, TError,{id: number;data: BodyType<ReviewInput>}, TContext> => {

const mutationKey = ['createReview'];
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 createReview>>, {id: number;data: BodyType<ReviewInput>}> = (props) => {
          const {id,data} = props ?? {};

          return  createReview(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateReviewMutationResult = NonNullable<Awaited<ReturnType<typeof createReview>>>
    export type CreateReviewMutationBody = BodyType<ReviewInput>
    export type CreateReviewMutationError = ErrorType<unknown>

    /**
 * @summary Submit a review
 */
export const useCreateReview = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createReview>>, TError,{id: number;data: BodyType<ReviewInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createReview>>,
        TError,
        {id: number;data: BodyType<ReviewInput>},
        TContext
      > => {
      return useMutation(getCreateReviewMutationOptions(options));
    }

export const getListBookingsUrl = () => {




  return `/api/bookings`
}

/**
 * @summary List bookings (admin sees all, user sees own)
 */
export const listBookings = async ( options?: RequestInit): Promise<Booking[]> => {

  return customFetch<Booking[]>(getListBookingsUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





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


export const getListBookingsQueryOptions = <TData = Awaited<ReturnType<typeof listBookings>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listBookings>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListBookingsQueryResult = NonNullable<Awaited<ReturnType<typeof listBookings>>>
export type ListBookingsQueryError = ErrorType<unknown>


/**
 * @summary List bookings (admin sees all, user sees own)
 */

export function useListBookings<TData = Awaited<ReturnType<typeof listBookings>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listBookings>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListBookingsQueryOptions(options)

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

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







export const getCreateBookingUrl = () => {




  return `/api/bookings`
}

/**
 * @summary Create a booking inquiry
 */
export const createBooking = async (bookingInput: BookingInput, options?: RequestInit): Promise<Booking> => {

  return customFetch<Booking>(getCreateBookingUrl(),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      bookingInput,)
  }
);}




export const getCreateBookingMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createBooking>>, TError,{data: BodyType<BookingInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createBooking>>, TError,{data: BodyType<BookingInput>}, TContext> => {

const mutationKey = ['createBooking'];
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 createBooking>>, {data: BodyType<BookingInput>}> = (props) => {
          const {data} = props ?? {};

          return  createBooking(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateBookingMutationResult = NonNullable<Awaited<ReturnType<typeof createBooking>>>
    export type CreateBookingMutationBody = BodyType<BookingInput>
    export type CreateBookingMutationError = ErrorType<unknown>

    /**
 * @summary Create a booking inquiry
 */
export const useCreateBooking = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createBooking>>, TError,{data: BodyType<BookingInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createBooking>>,
        TError,
        {data: BodyType<BookingInput>},
        TContext
      > => {
      return useMutation(getCreateBookingMutationOptions(options));
    }

export const getGetBookingUrl = (id: number,) => {




  return `/api/bookings/${id}`
}

/**
 * @summary Get booking detail
 */
export const getBooking = async (id: number, options?: RequestInit): Promise<Booking> => {

  return customFetch<Booking>(getGetBookingUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetBookingQueryKey = (id: number,) => {
    return [
    `/api/bookings/${id}`
    ] as const;
    }


export const getGetBookingQueryOptions = <TData = Awaited<ReturnType<typeof getBooking>>, TError = ErrorType<unknown>>(id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getBooking>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type GetBookingQueryResult = NonNullable<Awaited<ReturnType<typeof getBooking>>>
export type GetBookingQueryError = ErrorType<unknown>


/**
 * @summary Get booking detail
 */

export function useGetBooking<TData = Awaited<ReturnType<typeof getBooking>>, TError = ErrorType<unknown>>(
 id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getBooking>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getGetBookingQueryOptions(id,options)

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

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







export const getUpdateBookingStatusUrl = (id: number,) => {




  return `/api/bookings/${id}`
}

/**
 * @summary Update booking status (admin)
 */
export const updateBookingStatus = async (id: number,
    bookingStatusUpdate: BookingStatusUpdate, options?: RequestInit): Promise<Booking> => {

  return customFetch<Booking>(getUpdateBookingStatusUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      bookingStatusUpdate,)
  }
);}




export const getUpdateBookingStatusMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateBookingStatus>>, TError,{id: number;data: BodyType<BookingStatusUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateBookingStatus>>, TError,{id: number;data: BodyType<BookingStatusUpdate>}, TContext> => {

const mutationKey = ['updateBookingStatus'];
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 updateBookingStatus>>, {id: number;data: BodyType<BookingStatusUpdate>}> = (props) => {
          const {id,data} = props ?? {};

          return  updateBookingStatus(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateBookingStatusMutationResult = NonNullable<Awaited<ReturnType<typeof updateBookingStatus>>>
    export type UpdateBookingStatusMutationBody = BodyType<BookingStatusUpdate>
    export type UpdateBookingStatusMutationError = ErrorType<unknown>

    /**
 * @summary Update booking status (admin)
 */
export const useUpdateBookingStatus = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateBookingStatus>>, TError,{id: number;data: BodyType<BookingStatusUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateBookingStatus>>,
        TError,
        {id: number;data: BodyType<BookingStatusUpdate>},
        TContext
      > => {
      return useMutation(getUpdateBookingStatusMutationOptions(options));
    }

export const getListBlogPostsUrl = (params?: ListBlogPostsParams,) => {
  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 ? `/api/blog?${stringifiedParams}` : `/api/blog`
}

/**
 * @summary List published blog posts
 */
export const listBlogPosts = async (params?: ListBlogPostsParams, options?: RequestInit): Promise<BlogPost[]> => {

  return customFetch<BlogPost[]>(getListBlogPostsUrl(params),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListBlogPostsQueryKey = (params?: ListBlogPostsParams,) => {
    return [
    `/api/blog`, ...(params ? [params] : [])
    ] as const;
    }


export const getListBlogPostsQueryOptions = <TData = Awaited<ReturnType<typeof listBlogPosts>>, TError = ErrorType<unknown>>(params?: ListBlogPostsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listBlogPosts>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListBlogPostsQueryResult = NonNullable<Awaited<ReturnType<typeof listBlogPosts>>>
export type ListBlogPostsQueryError = ErrorType<unknown>


/**
 * @summary List published blog posts
 */

export function useListBlogPosts<TData = Awaited<ReturnType<typeof listBlogPosts>>, TError = ErrorType<unknown>>(
 params?: ListBlogPostsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listBlogPosts>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListBlogPostsQueryOptions(params,options)

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

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







export const getCreateBlogPostUrl = () => {




  return `/api/blog`
}

/**
 * @summary Create blog post (admin)
 */
export const createBlogPost = async (blogPostInput: BlogPostInput, options?: RequestInit): Promise<BlogPost> => {

  return customFetch<BlogPost>(getCreateBlogPostUrl(),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      blogPostInput,)
  }
);}




export const getCreateBlogPostMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createBlogPost>>, TError,{data: BodyType<BlogPostInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createBlogPost>>, TError,{data: BodyType<BlogPostInput>}, TContext> => {

const mutationKey = ['createBlogPost'];
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 createBlogPost>>, {data: BodyType<BlogPostInput>}> = (props) => {
          const {data} = props ?? {};

          return  createBlogPost(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateBlogPostMutationResult = NonNullable<Awaited<ReturnType<typeof createBlogPost>>>
    export type CreateBlogPostMutationBody = BodyType<BlogPostInput>
    export type CreateBlogPostMutationError = ErrorType<unknown>

    /**
 * @summary Create blog post (admin)
 */
export const useCreateBlogPost = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createBlogPost>>, TError,{data: BodyType<BlogPostInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createBlogPost>>,
        TError,
        {data: BodyType<BlogPostInput>},
        TContext
      > => {
      return useMutation(getCreateBlogPostMutationOptions(options));
    }

export const getListAllBlogPostsUrl = () => {




  return `/api/blog/all`
}

/**
 * @summary List all blog posts including drafts (admin)
 */
export const listAllBlogPosts = async ( options?: RequestInit): Promise<BlogPost[]> => {

  return customFetch<BlogPost[]>(getListAllBlogPostsUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListAllBlogPostsQueryKey = () => {
    return [
    `/api/blog/all`
    ] as const;
    }


export const getListAllBlogPostsQueryOptions = <TData = Awaited<ReturnType<typeof listAllBlogPosts>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listAllBlogPosts>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListAllBlogPostsQueryResult = NonNullable<Awaited<ReturnType<typeof listAllBlogPosts>>>
export type ListAllBlogPostsQueryError = ErrorType<unknown>


/**
 * @summary List all blog posts including drafts (admin)
 */

export function useListAllBlogPosts<TData = Awaited<ReturnType<typeof listAllBlogPosts>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listAllBlogPosts>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListAllBlogPostsQueryOptions(options)

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

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







export const getGetBlogPostUrl = (id: number,) => {




  return `/api/blog/${id}`
}

/**
 * @summary Get blog post detail
 */
export const getBlogPost = async (id: number, options?: RequestInit): Promise<BlogPost> => {

  return customFetch<BlogPost>(getGetBlogPostUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetBlogPostQueryKey = (id: number,) => {
    return [
    `/api/blog/${id}`
    ] as const;
    }


export const getGetBlogPostQueryOptions = <TData = Awaited<ReturnType<typeof getBlogPost>>, TError = ErrorType<unknown>>(id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getBlogPost>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type GetBlogPostQueryResult = NonNullable<Awaited<ReturnType<typeof getBlogPost>>>
export type GetBlogPostQueryError = ErrorType<unknown>


/**
 * @summary Get blog post detail
 */

export function useGetBlogPost<TData = Awaited<ReturnType<typeof getBlogPost>>, TError = ErrorType<unknown>>(
 id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getBlogPost>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getGetBlogPostQueryOptions(id,options)

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

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







export const getUpdateBlogPostUrl = (id: number,) => {




  return `/api/blog/${id}`
}

/**
 * @summary Update blog post (admin)
 */
export const updateBlogPost = async (id: number,
    blogPostUpdate: BlogPostUpdate, options?: RequestInit): Promise<BlogPost> => {

  return customFetch<BlogPost>(getUpdateBlogPostUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      blogPostUpdate,)
  }
);}




export const getUpdateBlogPostMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateBlogPost>>, TError,{id: number;data: BodyType<BlogPostUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateBlogPost>>, TError,{id: number;data: BodyType<BlogPostUpdate>}, TContext> => {

const mutationKey = ['updateBlogPost'];
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 updateBlogPost>>, {id: number;data: BodyType<BlogPostUpdate>}> = (props) => {
          const {id,data} = props ?? {};

          return  updateBlogPost(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateBlogPostMutationResult = NonNullable<Awaited<ReturnType<typeof updateBlogPost>>>
    export type UpdateBlogPostMutationBody = BodyType<BlogPostUpdate>
    export type UpdateBlogPostMutationError = ErrorType<unknown>

    /**
 * @summary Update blog post (admin)
 */
export const useUpdateBlogPost = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateBlogPost>>, TError,{id: number;data: BodyType<BlogPostUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateBlogPost>>,
        TError,
        {id: number;data: BodyType<BlogPostUpdate>},
        TContext
      > => {
      return useMutation(getUpdateBlogPostMutationOptions(options));
    }

export const getDeleteBlogPostUrl = (id: number,) => {




  return `/api/blog/${id}`
}

/**
 * @summary Delete blog post (admin)
 */
export const deleteBlogPost = async (id: number, options?: RequestInit): Promise<void> => {

  return customFetch<void>(getDeleteBlogPostUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}




export const getDeleteBlogPostMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteBlogPost>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteBlogPost>>, TError,{id: number}, TContext> => {

const mutationKey = ['deleteBlogPost'];
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 deleteBlogPost>>, {id: number}> = (props) => {
          const {id} = props ?? {};

          return  deleteBlogPost(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteBlogPostMutationResult = NonNullable<Awaited<ReturnType<typeof deleteBlogPost>>>

    export type DeleteBlogPostMutationError = ErrorType<unknown>

    /**
 * @summary Delete blog post (admin)
 */
export const useDeleteBlogPost = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteBlogPost>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteBlogPost>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeleteBlogPostMutationOptions(options));
    }

export const getGetBlogPostBySlugUrl = (slug: string,) => {




  return `/api/blog/slug/${slug}`
}

/**
 * @summary Get blog post by SEO slug
 */
export const getBlogPostBySlug = async (slug: string, options?: RequestInit): Promise<BlogPost> => {

  return customFetch<BlogPost>(getGetBlogPostBySlugUrl(slug),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetBlogPostBySlugQueryKey = (slug: string,) => {
    return [
    `/api/blog/slug/${slug}`
    ] as const;
    }


export const getGetBlogPostBySlugQueryOptions = <TData = Awaited<ReturnType<typeof getBlogPostBySlug>>, TError = ErrorType<unknown>>(slug: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getBlogPostBySlug>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

  const queryKey =  queryOptions?.queryKey ?? getGetBlogPostBySlugQueryKey(slug);



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





   return  { queryKey, queryFn, enabled: !!(slug), ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getBlogPostBySlug>>, TError, TData> & { queryKey: QueryKey }
}

export type GetBlogPostBySlugQueryResult = NonNullable<Awaited<ReturnType<typeof getBlogPostBySlug>>>
export type GetBlogPostBySlugQueryError = ErrorType<unknown>


/**
 * @summary Get blog post by SEO slug
 */

export function useGetBlogPostBySlug<TData = Awaited<ReturnType<typeof getBlogPostBySlug>>, TError = ErrorType<unknown>>(
 slug: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getBlogPostBySlug>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getGetBlogPostBySlugQueryOptions(slug,options)

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

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







export const getListContactsUrl = () => {




  return `/api/contacts`
}

/**
 * @summary List all form submissions (admin)
 */
export const listContacts = async ( options?: RequestInit): Promise<ContactSubmission[]> => {

  return customFetch<ContactSubmission[]>(getListContactsUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





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


export const getListContactsQueryOptions = <TData = Awaited<ReturnType<typeof listContacts>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listContacts>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListContactsQueryResult = NonNullable<Awaited<ReturnType<typeof listContacts>>>
export type ListContactsQueryError = ErrorType<unknown>


/**
 * @summary List all form submissions (admin)
 */

export function useListContacts<TData = Awaited<ReturnType<typeof listContacts>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listContacts>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListContactsQueryOptions(options)

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

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







export const getSubmitContactUrl = () => {




  return `/api/contacts`
}

/**
 * @summary Submit contact / quote form
 */
export const submitContact = async (contactInput: ContactInput, options?: RequestInit): Promise<ContactSubmission> => {

  return customFetch<ContactSubmission>(getSubmitContactUrl(),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      contactInput,)
  }
);}




export const getSubmitContactMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof submitContact>>, TError,{data: BodyType<ContactInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof submitContact>>, TError,{data: BodyType<ContactInput>}, TContext> => {

const mutationKey = ['submitContact'];
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 submitContact>>, {data: BodyType<ContactInput>}> = (props) => {
          const {data} = props ?? {};

          return  submitContact(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type SubmitContactMutationResult = NonNullable<Awaited<ReturnType<typeof submitContact>>>
    export type SubmitContactMutationBody = BodyType<ContactInput>
    export type SubmitContactMutationError = ErrorType<unknown>

    /**
 * @summary Submit contact / quote form
 */
export const useSubmitContact = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof submitContact>>, TError,{data: BodyType<ContactInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof submitContact>>,
        TError,
        {data: BodyType<ContactInput>},
        TContext
      > => {
      return useMutation(getSubmitContactMutationOptions(options));
    }

export const getSubscribeNewsletterUrl = () => {




  return `/api/newsletter`
}

/**
 * @summary Subscribe to newsletter
 */
export const subscribeNewsletter = async (newsletterInput: NewsletterInput, options?: RequestInit): Promise<NewsletterSubscriber> => {

  return customFetch<NewsletterSubscriber>(getSubscribeNewsletterUrl(),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      newsletterInput,)
  }
);}




export const getSubscribeNewsletterMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof subscribeNewsletter>>, TError,{data: BodyType<NewsletterInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof subscribeNewsletter>>, TError,{data: BodyType<NewsletterInput>}, TContext> => {

const mutationKey = ['subscribeNewsletter'];
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 subscribeNewsletter>>, {data: BodyType<NewsletterInput>}> = (props) => {
          const {data} = props ?? {};

          return  subscribeNewsletter(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type SubscribeNewsletterMutationResult = NonNullable<Awaited<ReturnType<typeof subscribeNewsletter>>>
    export type SubscribeNewsletterMutationBody = BodyType<NewsletterInput>
    export type SubscribeNewsletterMutationError = ErrorType<unknown>

    /**
 * @summary Subscribe to newsletter
 */
export const useSubscribeNewsletter = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof subscribeNewsletter>>, TError,{data: BodyType<NewsletterInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof subscribeNewsletter>>,
        TError,
        {data: BodyType<NewsletterInput>},
        TContext
      > => {
      return useMutation(getSubscribeNewsletterMutationOptions(options));
    }

export const getListNewsletterSubscribersUrl = () => {




  return `/api/newsletter/subscribers`
}

/**
 * @summary List newsletter subscribers (admin)
 */
export const listNewsletterSubscribers = async ( options?: RequestInit): Promise<NewsletterSubscriber[]> => {

  return customFetch<NewsletterSubscriber[]>(getListNewsletterSubscribersUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListNewsletterSubscribersQueryKey = () => {
    return [
    `/api/newsletter/subscribers`
    ] as const;
    }


export const getListNewsletterSubscribersQueryOptions = <TData = Awaited<ReturnType<typeof listNewsletterSubscribers>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listNewsletterSubscribers>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListNewsletterSubscribersQueryResult = NonNullable<Awaited<ReturnType<typeof listNewsletterSubscribers>>>
export type ListNewsletterSubscribersQueryError = ErrorType<unknown>


/**
 * @summary List newsletter subscribers (admin)
 */

export function useListNewsletterSubscribers<TData = Awaited<ReturnType<typeof listNewsletterSubscribers>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listNewsletterSubscribers>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListNewsletterSubscribersQueryOptions(options)

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

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







export const getListChatMessagesUrl = (params?: ListChatMessagesParams,) => {
  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 ? `/api/chat/messages?${stringifiedParams}` : `/api/chat/messages`
}

/**
 * @summary List chat messages for current session/apartment
 */
export const listChatMessages = async (params?: ListChatMessagesParams, options?: RequestInit): Promise<ChatMessage[]> => {

  return customFetch<ChatMessage[]>(getListChatMessagesUrl(params),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListChatMessagesQueryKey = (params?: ListChatMessagesParams,) => {
    return [
    `/api/chat/messages`, ...(params ? [params] : [])
    ] as const;
    }


export const getListChatMessagesQueryOptions = <TData = Awaited<ReturnType<typeof listChatMessages>>, TError = ErrorType<unknown>>(params?: ListChatMessagesParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listChatMessages>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListChatMessagesQueryResult = NonNullable<Awaited<ReturnType<typeof listChatMessages>>>
export type ListChatMessagesQueryError = ErrorType<unknown>


/**
 * @summary List chat messages for current session/apartment
 */

export function useListChatMessages<TData = Awaited<ReturnType<typeof listChatMessages>>, TError = ErrorType<unknown>>(
 params?: ListChatMessagesParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listChatMessages>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListChatMessagesQueryOptions(params,options)

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

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







export const getSendChatMessageUrl = () => {




  return `/api/chat/messages`
}

/**
 * @summary Send a chat message
 */
export const sendChatMessage = async (chatMessageInput: ChatMessageInput, options?: RequestInit): Promise<ChatMessage> => {

  return customFetch<ChatMessage>(getSendChatMessageUrl(),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      chatMessageInput,)
  }
);}




export const getSendChatMessageMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof sendChatMessage>>, TError,{data: BodyType<ChatMessageInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof sendChatMessage>>, TError,{data: BodyType<ChatMessageInput>}, TContext> => {

const mutationKey = ['sendChatMessage'];
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 sendChatMessage>>, {data: BodyType<ChatMessageInput>}> = (props) => {
          const {data} = props ?? {};

          return  sendChatMessage(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type SendChatMessageMutationResult = NonNullable<Awaited<ReturnType<typeof sendChatMessage>>>
    export type SendChatMessageMutationBody = BodyType<ChatMessageInput>
    export type SendChatMessageMutationError = ErrorType<unknown>

    /**
 * @summary Send a chat message
 */
export const useSendChatMessage = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof sendChatMessage>>, TError,{data: BodyType<ChatMessageInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof sendChatMessage>>,
        TError,
        {data: BodyType<ChatMessageInput>},
        TContext
      > => {
      return useMutation(getSendChatMessageMutationOptions(options));
    }

export const getListGalleryImagesUrl = (params?: ListGalleryImagesParams,) => {
  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 ? `/api/gallery?${stringifiedParams}` : `/api/gallery`
}

/**
 * @summary List gallery images
 */
export const listGalleryImages = async (params?: ListGalleryImagesParams, options?: RequestInit): Promise<GalleryImage[]> => {

  return customFetch<GalleryImage[]>(getListGalleryImagesUrl(params),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListGalleryImagesQueryKey = (params?: ListGalleryImagesParams,) => {
    return [
    `/api/gallery`, ...(params ? [params] : [])
    ] as const;
    }


export const getListGalleryImagesQueryOptions = <TData = Awaited<ReturnType<typeof listGalleryImages>>, TError = ErrorType<unknown>>(params?: ListGalleryImagesParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listGalleryImages>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListGalleryImagesQueryResult = NonNullable<Awaited<ReturnType<typeof listGalleryImages>>>
export type ListGalleryImagesQueryError = ErrorType<unknown>


/**
 * @summary List gallery images
 */

export function useListGalleryImages<TData = Awaited<ReturnType<typeof listGalleryImages>>, TError = ErrorType<unknown>>(
 params?: ListGalleryImagesParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listGalleryImages>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListGalleryImagesQueryOptions(params,options)

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

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







export const getCreateGalleryImageUrl = () => {




  return `/api/gallery`
}

/**
 * @summary Upload gallery image (admin)
 */
export const createGalleryImage = async (galleryImageInput: GalleryImageInput, options?: RequestInit): Promise<GalleryImage> => {

  return customFetch<GalleryImage>(getCreateGalleryImageUrl(),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      galleryImageInput,)
  }
);}




export const getCreateGalleryImageMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createGalleryImage>>, TError,{data: BodyType<GalleryImageInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createGalleryImage>>, TError,{data: BodyType<GalleryImageInput>}, TContext> => {

const mutationKey = ['createGalleryImage'];
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 createGalleryImage>>, {data: BodyType<GalleryImageInput>}> = (props) => {
          const {data} = props ?? {};

          return  createGalleryImage(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateGalleryImageMutationResult = NonNullable<Awaited<ReturnType<typeof createGalleryImage>>>
    export type CreateGalleryImageMutationBody = BodyType<GalleryImageInput>
    export type CreateGalleryImageMutationError = ErrorType<unknown>

    /**
 * @summary Upload gallery image (admin)
 */
export const useCreateGalleryImage = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createGalleryImage>>, TError,{data: BodyType<GalleryImageInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createGalleryImage>>,
        TError,
        {data: BodyType<GalleryImageInput>},
        TContext
      > => {
      return useMutation(getCreateGalleryImageMutationOptions(options));
    }

export const getDeleteGalleryImageUrl = (id: number,) => {




  return `/api/gallery/${id}`
}

/**
 * @summary Delete gallery image (admin)
 */
export const deleteGalleryImage = async (id: number, options?: RequestInit): Promise<void> => {

  return customFetch<void>(getDeleteGalleryImageUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}




export const getDeleteGalleryImageMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteGalleryImage>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteGalleryImage>>, TError,{id: number}, TContext> => {

const mutationKey = ['deleteGalleryImage'];
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 deleteGalleryImage>>, {id: number}> = (props) => {
          const {id} = props ?? {};

          return  deleteGalleryImage(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteGalleryImageMutationResult = NonNullable<Awaited<ReturnType<typeof deleteGalleryImage>>>

    export type DeleteGalleryImageMutationError = ErrorType<unknown>

    /**
 * @summary Delete gallery image (admin)
 */
export const useDeleteGalleryImage = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteGalleryImage>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteGalleryImage>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeleteGalleryImageMutationOptions(options));
    }

export const getUpdateContactUrl = (id: number,) => {




  return `/api/contacts/${id}`
}

/**
 * @summary Update contact status (admin)
 */
export const updateContact = async (id: number,
    contactStatusUpdate: ContactStatusUpdate, options?: RequestInit): Promise<ContactSubmission> => {

  return customFetch<ContactSubmission>(getUpdateContactUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      contactStatusUpdate,)
  }
);}




export const getUpdateContactMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateContact>>, TError,{id: number;data: BodyType<ContactStatusUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateContact>>, TError,{id: number;data: BodyType<ContactStatusUpdate>}, TContext> => {

const mutationKey = ['updateContact'];
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 updateContact>>, {id: number;data: BodyType<ContactStatusUpdate>}> = (props) => {
          const {id,data} = props ?? {};

          return  updateContact(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateContactMutationResult = NonNullable<Awaited<ReturnType<typeof updateContact>>>
    export type UpdateContactMutationBody = BodyType<ContactStatusUpdate>
    export type UpdateContactMutationError = ErrorType<unknown>

    /**
 * @summary Update contact status (admin)
 */
export const useUpdateContact = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateContact>>, TError,{id: number;data: BodyType<ContactStatusUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateContact>>,
        TError,
        {id: number;data: BodyType<ContactStatusUpdate>},
        TContext
      > => {
      return useMutation(getUpdateContactMutationOptions(options));
    }

export const getListServicePackagesUrl = (params?: ListServicePackagesParams,) => {
  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 ? `/api/service-packages?${stringifiedParams}` : `/api/service-packages`
}

/**
 * @summary List service packages
 */
export const listServicePackages = async (params?: ListServicePackagesParams, options?: RequestInit): Promise<ServicePackage[]> => {

  return customFetch<ServicePackage[]>(getListServicePackagesUrl(params),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListServicePackagesQueryKey = (params?: ListServicePackagesParams,) => {
    return [
    `/api/service-packages`, ...(params ? [params] : [])
    ] as const;
    }


export const getListServicePackagesQueryOptions = <TData = Awaited<ReturnType<typeof listServicePackages>>, TError = ErrorType<unknown>>(params?: ListServicePackagesParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listServicePackages>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type ListServicePackagesQueryResult = NonNullable<Awaited<ReturnType<typeof listServicePackages>>>
export type ListServicePackagesQueryError = ErrorType<unknown>


/**
 * @summary List service packages
 */

export function useListServicePackages<TData = Awaited<ReturnType<typeof listServicePackages>>, TError = ErrorType<unknown>>(
 params?: ListServicePackagesParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listServicePackages>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListServicePackagesQueryOptions(params,options)

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

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







export const getUpdateServicePackageUrl = (id: number,) => {




  return `/api/service-packages/${id}`
}

/**
 * @summary Update service package price/description (admin)
 */
export const updateServicePackage = async (id: number,
    servicePackageUpdate: ServicePackageUpdate, options?: RequestInit): Promise<ServicePackage> => {

  return customFetch<ServicePackage>(getUpdateServicePackageUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      servicePackageUpdate,)
  }
);}




export const getUpdateServicePackageMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateServicePackage>>, TError,{id: number;data: BodyType<ServicePackageUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateServicePackage>>, TError,{id: number;data: BodyType<ServicePackageUpdate>}, TContext> => {

const mutationKey = ['updateServicePackage'];
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 updateServicePackage>>, {id: number;data: BodyType<ServicePackageUpdate>}> = (props) => {
          const {id,data} = props ?? {};

          return  updateServicePackage(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateServicePackageMutationResult = NonNullable<Awaited<ReturnType<typeof updateServicePackage>>>
    export type UpdateServicePackageMutationBody = BodyType<ServicePackageUpdate>
    export type UpdateServicePackageMutationError = ErrorType<unknown>

    /**
 * @summary Update service package price/description (admin)
 */
export const useUpdateServicePackage = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateServicePackage>>, TError,{id: number;data: BodyType<ServicePackageUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateServicePackage>>,
        TError,
        {id: number;data: BodyType<ServicePackageUpdate>},
        TContext
      > => {
      return useMutation(getUpdateServicePackageMutationOptions(options));
    }

export const getGetDashboardStatsUrl = () => {




  return `/api/stats/dashboard`
}

/**
 * @summary Admin dashboard summary stats
 */
export const getDashboardStats = async ( options?: RequestInit): Promise<DashboardStats> => {

  return customFetch<DashboardStats>(getGetDashboardStatsUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetDashboardStatsQueryKey = () => {
    return [
    `/api/stats/dashboard`
    ] as const;
    }


export const getGetDashboardStatsQueryOptions = <TData = Awaited<ReturnType<typeof getDashboardStats>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getDashboardStats>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type GetDashboardStatsQueryResult = NonNullable<Awaited<ReturnType<typeof getDashboardStats>>>
export type GetDashboardStatsQueryError = ErrorType<unknown>


/**
 * @summary Admin dashboard summary stats
 */

export function useGetDashboardStats<TData = Awaited<ReturnType<typeof getDashboardStats>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getDashboardStats>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getGetDashboardStatsQueryOptions(options)

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

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







export const getGetCityStatsUrl = () => {




  return `/api/stats/cities`
}

/**
 * @summary Apartment count and avg price per city
 */
export const getCityStats = async ( options?: RequestInit): Promise<CityStats[]> => {

  return customFetch<CityStats[]>(getGetCityStatsUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetCityStatsQueryKey = () => {
    return [
    `/api/stats/cities`
    ] as const;
    }


export const getGetCityStatsQueryOptions = <TData = Awaited<ReturnType<typeof getCityStats>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getCityStats>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

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



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





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

export type GetCityStatsQueryResult = NonNullable<Awaited<ReturnType<typeof getCityStats>>>
export type GetCityStatsQueryError = ErrorType<unknown>


/**
 * @summary Apartment count and avg price per city
 */

export function useGetCityStats<TData = Awaited<ReturnType<typeof getCityStats>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getCityStats>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getGetCityStatsQueryOptions(options)

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

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