import type { 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 declare const getHealthCheckUrl: () => string;
/**
 * @summary Health check
 */
export declare const healthCheck: (options?: RequestInit) => Promise<HealthStatus>;
export declare const getHealthCheckQueryKey: () => readonly ["/api/healthz"];
export declare const getHealthCheckQueryOptions: <TData = Awaited<ReturnType<typeof healthCheck>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof healthCheck>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => 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 declare 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;
};
export declare const getListApartmentsUrl: (params?: ListApartmentsParams) => string;
/**
 * @summary List apartments with optional filters
 */
export declare const listApartments: (params?: ListApartmentsParams, options?: RequestInit) => Promise<Apartment[]>;
export declare const getListApartmentsQueryKey: (params?: ListApartmentsParams) => readonly ["/api/apartments", ...ListApartmentsParams[]];
export declare 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>;
}) => 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 declare 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;
};
export declare const getCreateApartmentUrl: () => string;
/**
 * @summary Create a new apartment listing (admin)
 */
export declare const createApartment: (apartmentInput: ApartmentInput, options?: RequestInit) => Promise<Apartment>;
export declare 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>;
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 declare 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>;
export declare const getListFeaturedApartmentsUrl: () => string;
/**
 * @summary Get featured/highlighted apartments for homepage
 */
export declare const listFeaturedApartments: (options?: RequestInit) => Promise<Apartment[]>;
export declare const getListFeaturedApartmentsQueryKey: () => readonly ["/api/apartments/featured"];
export declare const getListFeaturedApartmentsQueryOptions: <TData = Awaited<ReturnType<typeof listFeaturedApartments>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listFeaturedApartments>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => 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 declare 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;
};
export declare const getListCitiesUrl: () => string;
/**
 * @summary Get list of cities with apartment counts
 */
export declare const listCities: (options?: RequestInit) => Promise<CityCount[]>;
export declare const getListCitiesQueryKey: () => readonly ["/api/apartments/cities"];
export declare const getListCitiesQueryOptions: <TData = Awaited<ReturnType<typeof listCities>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listCities>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => 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 declare 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;
};
export declare const getGetApartmentUrl: (id: number) => string;
/**
 * @summary Get apartment detail
 */
export declare const getApartment: (id: number, options?: RequestInit) => Promise<Apartment>;
export declare const getGetApartmentQueryKey: (id: number) => readonly [`/api/apartments/${number}`];
export declare 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>;
}) => 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 declare 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;
};
export declare const getUpdateApartmentUrl: (id: number) => string;
/**
 * @summary Update apartment (admin)
 */
export declare const updateApartment: (id: number, apartmentUpdate: ApartmentUpdate, options?: RequestInit) => Promise<Apartment>;
export declare 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>;
export type UpdateApartmentMutationResult = NonNullable<Awaited<ReturnType<typeof updateApartment>>>;
export type UpdateApartmentMutationBody = BodyType<ApartmentUpdate>;
export type UpdateApartmentMutationError = ErrorType<unknown>;
/**
* @summary Update apartment (admin)
*/
export declare 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>;
export declare const getDeleteApartmentUrl: (id: number) => string;
/**
 * @summary Delete apartment (admin)
 */
export declare const deleteApartment: (id: number, options?: RequestInit) => Promise<void>;
export declare 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>;
export type DeleteApartmentMutationResult = NonNullable<Awaited<ReturnType<typeof deleteApartment>>>;
export type DeleteApartmentMutationError = ErrorType<unknown>;
/**
* @summary Delete apartment (admin)
*/
export declare 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>;
export declare const getGetApartmentAvailabilityUrl: (id: number) => string;
/**
 * @summary Get booked date ranges for an apartment
 */
export declare const getApartmentAvailability: (id: number, options?: RequestInit) => Promise<BookedDateRange[]>;
export declare const getGetApartmentAvailabilityQueryKey: (id: number) => readonly [`/api/apartments/${number}/availability`];
export declare 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>;
}) => 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 declare 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;
};
export declare const getUpdateApartmentAvailabilityUrl: (id: number) => string;
/**
 * @summary Toggle apartment availability (admin)
 */
export declare const updateApartmentAvailability: (id: number, availabilityUpdate: AvailabilityUpdate, options?: RequestInit) => Promise<Apartment>;
export declare 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>;
export type UpdateApartmentAvailabilityMutationResult = NonNullable<Awaited<ReturnType<typeof updateApartmentAvailability>>>;
export type UpdateApartmentAvailabilityMutationBody = BodyType<AvailabilityUpdate>;
export type UpdateApartmentAvailabilityMutationError = ErrorType<unknown>;
/**
* @summary Toggle apartment availability (admin)
*/
export declare 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>;
export declare const getListApartmentReviewsUrl: (id: number) => string;
/**
 * @summary Get reviews for an apartment
 */
export declare const listApartmentReviews: (id: number, options?: RequestInit) => Promise<Review[]>;
export declare const getListApartmentReviewsQueryKey: (id: number) => readonly [`/api/apartments/${number}/reviews`];
export declare 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>;
}) => 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 declare 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;
};
export declare const getCreateReviewUrl: (id: number) => string;
/**
 * @summary Submit a review
 */
export declare const createReview: (id: number, reviewInput: ReviewInput, options?: RequestInit) => Promise<Review>;
export declare 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>;
export type CreateReviewMutationResult = NonNullable<Awaited<ReturnType<typeof createReview>>>;
export type CreateReviewMutationBody = BodyType<ReviewInput>;
export type CreateReviewMutationError = ErrorType<unknown>;
/**
* @summary Submit a review
*/
export declare 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>;
export declare const getListBookingsUrl: () => string;
/**
 * @summary List bookings (admin sees all, user sees own)
 */
export declare const listBookings: (options?: RequestInit) => Promise<Booking[]>;
export declare const getListBookingsQueryKey: () => readonly ["/api/bookings"];
export declare const getListBookingsQueryOptions: <TData = Awaited<ReturnType<typeof listBookings>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listBookings>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => 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 declare 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;
};
export declare const getCreateBookingUrl: () => string;
/**
 * @summary Create a booking inquiry
 */
export declare const createBooking: (bookingInput: BookingInput, options?: RequestInit) => Promise<Booking>;
export declare 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>;
export type CreateBookingMutationResult = NonNullable<Awaited<ReturnType<typeof createBooking>>>;
export type CreateBookingMutationBody = BodyType<BookingInput>;
export type CreateBookingMutationError = ErrorType<unknown>;
/**
* @summary Create a booking inquiry
*/
export declare 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>;
export declare const getGetBookingUrl: (id: number) => string;
/**
 * @summary Get booking detail
 */
export declare const getBooking: (id: number, options?: RequestInit) => Promise<Booking>;
export declare const getGetBookingQueryKey: (id: number) => readonly [`/api/bookings/${number}`];
export declare 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>;
}) => 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 declare 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;
};
export declare const getUpdateBookingStatusUrl: (id: number) => string;
/**
 * @summary Update booking status (admin)
 */
export declare const updateBookingStatus: (id: number, bookingStatusUpdate: BookingStatusUpdate, options?: RequestInit) => Promise<Booking>;
export declare 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>;
export type UpdateBookingStatusMutationResult = NonNullable<Awaited<ReturnType<typeof updateBookingStatus>>>;
export type UpdateBookingStatusMutationBody = BodyType<BookingStatusUpdate>;
export type UpdateBookingStatusMutationError = ErrorType<unknown>;
/**
* @summary Update booking status (admin)
*/
export declare 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>;
export declare const getListBlogPostsUrl: (params?: ListBlogPostsParams) => string;
/**
 * @summary List published blog posts
 */
export declare const listBlogPosts: (params?: ListBlogPostsParams, options?: RequestInit) => Promise<BlogPost[]>;
export declare const getListBlogPostsQueryKey: (params?: ListBlogPostsParams) => readonly ["/api/blog", ...ListBlogPostsParams[]];
export declare 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>;
}) => 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 declare 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;
};
export declare const getCreateBlogPostUrl: () => string;
/**
 * @summary Create blog post (admin)
 */
export declare const createBlogPost: (blogPostInput: BlogPostInput, options?: RequestInit) => Promise<BlogPost>;
export declare 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>;
export type CreateBlogPostMutationResult = NonNullable<Awaited<ReturnType<typeof createBlogPost>>>;
export type CreateBlogPostMutationBody = BodyType<BlogPostInput>;
export type CreateBlogPostMutationError = ErrorType<unknown>;
/**
* @summary Create blog post (admin)
*/
export declare 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>;
export declare const getListAllBlogPostsUrl: () => string;
/**
 * @summary List all blog posts including drafts (admin)
 */
export declare const listAllBlogPosts: (options?: RequestInit) => Promise<BlogPost[]>;
export declare const getListAllBlogPostsQueryKey: () => readonly ["/api/blog/all"];
export declare const getListAllBlogPostsQueryOptions: <TData = Awaited<ReturnType<typeof listAllBlogPosts>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listAllBlogPosts>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => 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 declare 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;
};
export declare const getGetBlogPostUrl: (id: number) => string;
/**
 * @summary Get blog post detail
 */
export declare const getBlogPost: (id: number, options?: RequestInit) => Promise<BlogPost>;
export declare const getGetBlogPostQueryKey: (id: number) => readonly [`/api/blog/${number}`];
export declare 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>;
}) => 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 declare 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;
};
export declare const getUpdateBlogPostUrl: (id: number) => string;
/**
 * @summary Update blog post (admin)
 */
export declare const updateBlogPost: (id: number, blogPostUpdate: BlogPostUpdate, options?: RequestInit) => Promise<BlogPost>;
export declare 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>;
export type UpdateBlogPostMutationResult = NonNullable<Awaited<ReturnType<typeof updateBlogPost>>>;
export type UpdateBlogPostMutationBody = BodyType<BlogPostUpdate>;
export type UpdateBlogPostMutationError = ErrorType<unknown>;
/**
* @summary Update blog post (admin)
*/
export declare 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>;
export declare const getDeleteBlogPostUrl: (id: number) => string;
/**
 * @summary Delete blog post (admin)
 */
export declare const deleteBlogPost: (id: number, options?: RequestInit) => Promise<void>;
export declare 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>;
export type DeleteBlogPostMutationResult = NonNullable<Awaited<ReturnType<typeof deleteBlogPost>>>;
export type DeleteBlogPostMutationError = ErrorType<unknown>;
/**
* @summary Delete blog post (admin)
*/
export declare 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>;
export declare const getGetBlogPostBySlugUrl: (slug: string) => string;
/**
 * @summary Get blog post by SEO slug
 */
export declare const getBlogPostBySlug: (slug: string, options?: RequestInit) => Promise<BlogPost>;
export declare const getGetBlogPostBySlugQueryKey: (slug: string) => readonly [`/api/blog/slug/${string}`];
export declare 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>;
}) => 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 declare 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;
};
export declare const getListContactsUrl: () => string;
/**
 * @summary List all form submissions (admin)
 */
export declare const listContacts: (options?: RequestInit) => Promise<ContactSubmission[]>;
export declare const getListContactsQueryKey: () => readonly ["/api/contacts"];
export declare const getListContactsQueryOptions: <TData = Awaited<ReturnType<typeof listContacts>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listContacts>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => 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 declare 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;
};
export declare const getSubmitContactUrl: () => string;
/**
 * @summary Submit contact / quote form
 */
export declare const submitContact: (contactInput: ContactInput, options?: RequestInit) => Promise<ContactSubmission>;
export declare 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>;
export type SubmitContactMutationResult = NonNullable<Awaited<ReturnType<typeof submitContact>>>;
export type SubmitContactMutationBody = BodyType<ContactInput>;
export type SubmitContactMutationError = ErrorType<unknown>;
/**
* @summary Submit contact / quote form
*/
export declare 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>;
export declare const getSubscribeNewsletterUrl: () => string;
/**
 * @summary Subscribe to newsletter
 */
export declare const subscribeNewsletter: (newsletterInput: NewsletterInput, options?: RequestInit) => Promise<NewsletterSubscriber>;
export declare 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>;
export type SubscribeNewsletterMutationResult = NonNullable<Awaited<ReturnType<typeof subscribeNewsletter>>>;
export type SubscribeNewsletterMutationBody = BodyType<NewsletterInput>;
export type SubscribeNewsletterMutationError = ErrorType<unknown>;
/**
* @summary Subscribe to newsletter
*/
export declare 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>;
export declare const getListNewsletterSubscribersUrl: () => string;
/**
 * @summary List newsletter subscribers (admin)
 */
export declare const listNewsletterSubscribers: (options?: RequestInit) => Promise<NewsletterSubscriber[]>;
export declare const getListNewsletterSubscribersQueryKey: () => readonly ["/api/newsletter/subscribers"];
export declare const getListNewsletterSubscribersQueryOptions: <TData = Awaited<ReturnType<typeof listNewsletterSubscribers>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listNewsletterSubscribers>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => 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 declare 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;
};
export declare const getListChatMessagesUrl: (params?: ListChatMessagesParams) => string;
/**
 * @summary List chat messages for current session/apartment
 */
export declare const listChatMessages: (params?: ListChatMessagesParams, options?: RequestInit) => Promise<ChatMessage[]>;
export declare const getListChatMessagesQueryKey: (params?: ListChatMessagesParams) => readonly ["/api/chat/messages", ...ListChatMessagesParams[]];
export declare 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>;
}) => 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 declare 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;
};
export declare const getSendChatMessageUrl: () => string;
/**
 * @summary Send a chat message
 */
export declare const sendChatMessage: (chatMessageInput: ChatMessageInput, options?: RequestInit) => Promise<ChatMessage>;
export declare 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>;
export type SendChatMessageMutationResult = NonNullable<Awaited<ReturnType<typeof sendChatMessage>>>;
export type SendChatMessageMutationBody = BodyType<ChatMessageInput>;
export type SendChatMessageMutationError = ErrorType<unknown>;
/**
* @summary Send a chat message
*/
export declare 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>;
export declare const getListGalleryImagesUrl: (params?: ListGalleryImagesParams) => string;
/**
 * @summary List gallery images
 */
export declare const listGalleryImages: (params?: ListGalleryImagesParams, options?: RequestInit) => Promise<GalleryImage[]>;
export declare const getListGalleryImagesQueryKey: (params?: ListGalleryImagesParams) => readonly ["/api/gallery", ...ListGalleryImagesParams[]];
export declare 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>;
}) => 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 declare 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;
};
export declare const getCreateGalleryImageUrl: () => string;
/**
 * @summary Upload gallery image (admin)
 */
export declare const createGalleryImage: (galleryImageInput: GalleryImageInput, options?: RequestInit) => Promise<GalleryImage>;
export declare 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>;
export type CreateGalleryImageMutationResult = NonNullable<Awaited<ReturnType<typeof createGalleryImage>>>;
export type CreateGalleryImageMutationBody = BodyType<GalleryImageInput>;
export type CreateGalleryImageMutationError = ErrorType<unknown>;
/**
* @summary Upload gallery image (admin)
*/
export declare 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>;
export declare const getDeleteGalleryImageUrl: (id: number) => string;
/**
 * @summary Delete gallery image (admin)
 */
export declare const deleteGalleryImage: (id: number, options?: RequestInit) => Promise<void>;
export declare 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>;
export type DeleteGalleryImageMutationResult = NonNullable<Awaited<ReturnType<typeof deleteGalleryImage>>>;
export type DeleteGalleryImageMutationError = ErrorType<unknown>;
/**
* @summary Delete gallery image (admin)
*/
export declare 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>;
export declare const getUpdateContactUrl: (id: number) => string;
/**
 * @summary Update contact status (admin)
 */
export declare const updateContact: (id: number, contactStatusUpdate: ContactStatusUpdate, options?: RequestInit) => Promise<ContactSubmission>;
export declare 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>;
export type UpdateContactMutationResult = NonNullable<Awaited<ReturnType<typeof updateContact>>>;
export type UpdateContactMutationBody = BodyType<ContactStatusUpdate>;
export type UpdateContactMutationError = ErrorType<unknown>;
/**
* @summary Update contact status (admin)
*/
export declare 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>;
export declare const getListServicePackagesUrl: (params?: ListServicePackagesParams) => string;
/**
 * @summary List service packages
 */
export declare const listServicePackages: (params?: ListServicePackagesParams, options?: RequestInit) => Promise<ServicePackage[]>;
export declare const getListServicePackagesQueryKey: (params?: ListServicePackagesParams) => readonly ["/api/service-packages", ...ListServicePackagesParams[]];
export declare 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>;
}) => 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 declare 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;
};
export declare const getUpdateServicePackageUrl: (id: number) => string;
/**
 * @summary Update service package price/description (admin)
 */
export declare const updateServicePackage: (id: number, servicePackageUpdate: ServicePackageUpdate, options?: RequestInit) => Promise<ServicePackage>;
export declare 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>;
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 declare 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>;
export declare const getGetDashboardStatsUrl: () => string;
/**
 * @summary Admin dashboard summary stats
 */
export declare const getDashboardStats: (options?: RequestInit) => Promise<DashboardStats>;
export declare const getGetDashboardStatsQueryKey: () => readonly ["/api/stats/dashboard"];
export declare const getGetDashboardStatsQueryOptions: <TData = Awaited<ReturnType<typeof getDashboardStats>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getDashboardStats>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => 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 declare 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;
};
export declare const getGetCityStatsUrl: () => string;
/**
 * @summary Apartment count and avg price per city
 */
export declare const getCityStats: (options?: RequestInit) => Promise<CityStats[]>;
export declare const getGetCityStatsQueryKey: () => readonly ["/api/stats/cities"];
export declare const getGetCityStatsQueryOptions: <TData = Awaited<ReturnType<typeof getCityStats>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getCityStats>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => 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 declare 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;
};
export {};
//# sourceMappingURL=api.d.ts.map