import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
import type { AddPhotoInput, AdminOrderProof, AdminWallet, Asset, AuthResponse, Booking, BookingInput, BookingStatusInput, CommissionStats, DashboardSummary, DepositInput, EarningsSummary, ErrorEnvelope, EscrowStats, FavoriteInput, ForgotPasswordInput, HealthStatus, ListLocationsParams, ListProfilesParams, Location, LocationInput, LocationUpdate, LoginInput, Membership, MembershipPayment, MembershipPaymentReview, MembershipPlan, MembershipPlanInput, MembershipPlanUpdate, MembershipUpdate, ModelProfileUpdate, NetworkMember, PaymentMethod, PaymentMethodUpdate, Profile, ProfileInput, ProfilePhoto, ProfileUpdate, ProofReviewInput, ProofUploadInput, RegisterInput, RegisterModelAccountInput, RegisterModelInput, ResetPasswordInput, Service, SubscribeInput, UploadUrlRequest, UploadUrlResponse, User, UserUpdate, Wallet, WalletCreditInput, WalletDeposit, WalletReview, WalletTransaction, Withdrawal, WithdrawalInput } 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 getRequestUploadUrlUrl: () => string;
/**
 * Returns a presigned GCS URL for direct upload. The client sends JSON
metadata here, then uploads the file directly to the returned URL.

 * @summary Request a presigned URL for file upload
 */
export declare const requestUploadUrl: (uploadUrlRequest: UploadUrlRequest, options?: RequestInit) => Promise<UploadUrlResponse>;
export declare const getRequestUploadUrlMutationOptions: <TError = ErrorType<ErrorEnvelope>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof requestUploadUrl>>, TError, {
        data: BodyType<UploadUrlRequest>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof requestUploadUrl>>, TError, {
    data: BodyType<UploadUrlRequest>;
}, TContext>;
export type RequestUploadUrlMutationResult = NonNullable<Awaited<ReturnType<typeof requestUploadUrl>>>;
export type RequestUploadUrlMutationBody = BodyType<UploadUrlRequest>;
export type RequestUploadUrlMutationError = ErrorType<ErrorEnvelope>;
/**
* @summary Request a presigned URL for file upload
*/
export declare const useRequestUploadUrl: <TError = ErrorType<ErrorEnvelope>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof requestUploadUrl>>, TError, {
        data: BodyType<UploadUrlRequest>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof requestUploadUrl>>, TError, {
    data: BodyType<UploadUrlRequest>;
}, TContext>;
export declare const getGetPublicObjectUrl: (filePath: string) => string;
/**
 * Unconditionally public — no authentication or ACL checks.
Searches PUBLIC_OBJECT_SEARCH_PATHS for the given file path.

 * @summary Serve a public asset from PUBLIC_OBJECT_SEARCH_PATHS
 */
export declare const getPublicObject: (filePath: string, options?: RequestInit) => Promise<Blob>;
export declare const getGetPublicObjectQueryKey: (filePath: string) => readonly [`/api/storage/public-objects/${string}`];
export declare const getGetPublicObjectQueryOptions: <TData = Awaited<ReturnType<typeof getPublicObject>>, TError = ErrorType<ErrorEnvelope>>(filePath: string, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getPublicObject>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getPublicObject>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetPublicObjectQueryResult = NonNullable<Awaited<ReturnType<typeof getPublicObject>>>;
export type GetPublicObjectQueryError = ErrorType<ErrorEnvelope>;
/**
 * @summary Serve a public asset from PUBLIC_OBJECT_SEARCH_PATHS
 */
export declare function useGetPublicObject<TData = Awaited<ReturnType<typeof getPublicObject>>, TError = ErrorType<ErrorEnvelope>>(filePath: string, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getPublicObject>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getGetStorageObjectUrl: (objectPath: string) => string;
/**
 * Serves object entities uploaded via presigned URLs. These can optionally
be protected with authentication or ACL checks based on the use case.

 * @summary Serve an object entity from PRIVATE_OBJECT_DIR
 */
export declare const getStorageObject: (objectPath: string, options?: RequestInit) => Promise<Blob>;
export declare const getGetStorageObjectQueryKey: (objectPath: string) => readonly [`/api/storage/objects/${string}`];
export declare const getGetStorageObjectQueryOptions: <TData = Awaited<ReturnType<typeof getStorageObject>>, TError = ErrorType<ErrorEnvelope>>(objectPath: string, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getStorageObject>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getStorageObject>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetStorageObjectQueryResult = NonNullable<Awaited<ReturnType<typeof getStorageObject>>>;
export type GetStorageObjectQueryError = ErrorType<ErrorEnvelope>;
/**
 * @summary Serve an object entity from PRIVATE_OBJECT_DIR
 */
export declare function useGetStorageObject<TData = Awaited<ReturnType<typeof getStorageObject>>, TError = ErrorType<ErrorEnvelope>>(objectPath: string, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getStorageObject>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
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 getRegisterUrl: () => string;
/**
 * @summary Register a new user
 */
export declare const register: (registerInput: RegisterInput, options?: RequestInit) => Promise<AuthResponse>;
export declare const getRegisterMutationOptions: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof register>>, TError, {
        data: BodyType<RegisterInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof register>>, TError, {
    data: BodyType<RegisterInput>;
}, TContext>;
export type RegisterMutationResult = NonNullable<Awaited<ReturnType<typeof register>>>;
export type RegisterMutationBody = BodyType<RegisterInput>;
export type RegisterMutationError = ErrorType<void>;
/**
* @summary Register a new user
*/
export declare const useRegister: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof register>>, TError, {
        data: BodyType<RegisterInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof register>>, TError, {
    data: BodyType<RegisterInput>;
}, TContext>;
export declare const getLoginUrl: () => string;
/**
 * @summary Log in
 */
export declare const login: (loginInput: LoginInput, options?: RequestInit) => Promise<AuthResponse>;
export declare const getLoginMutationOptions: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof login>>, TError, {
        data: BodyType<LoginInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof login>>, TError, {
    data: BodyType<LoginInput>;
}, TContext>;
export type LoginMutationResult = NonNullable<Awaited<ReturnType<typeof login>>>;
export type LoginMutationBody = BodyType<LoginInput>;
export type LoginMutationError = ErrorType<void>;
/**
* @summary Log in
*/
export declare const useLogin: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof login>>, TError, {
        data: BodyType<LoginInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof login>>, TError, {
    data: BodyType<LoginInput>;
}, TContext>;
export declare const getLogoutUrl: () => string;
/**
 * @summary Log out
 */
export declare const logout: (options?: RequestInit) => Promise<void>;
export declare const getLogoutMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof logout>>, TError, void, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof logout>>, TError, void, TContext>;
export type LogoutMutationResult = NonNullable<Awaited<ReturnType<typeof logout>>>;
export type LogoutMutationError = ErrorType<unknown>;
/**
* @summary Log out
*/
export declare const useLogout: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof logout>>, TError, void, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof logout>>, TError, void, TContext>;
export declare const getGetMeUrl: () => string;
/**
 * @summary Get current user
 */
export declare const getMe: (options?: RequestInit) => Promise<User>;
export declare const getGetMeQueryKey: () => readonly ["/api/auth/me"];
export declare const getGetMeQueryOptions: <TData = Awaited<ReturnType<typeof getMe>>, TError = ErrorType<void>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getMe>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getMe>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetMeQueryResult = NonNullable<Awaited<ReturnType<typeof getMe>>>;
export type GetMeQueryError = ErrorType<void>;
/**
 * @summary Get current user
 */
export declare function useGetMe<TData = Awaited<ReturnType<typeof getMe>>, TError = ErrorType<void>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getMe>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getUpdateMeUrl: () => string;
/**
 * @summary Update current user profile
 */
export declare const updateMe: (userUpdate: UserUpdate, options?: RequestInit) => Promise<User>;
export declare const getUpdateMeMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateMe>>, TError, {
        data: BodyType<UserUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof updateMe>>, TError, {
    data: BodyType<UserUpdate>;
}, TContext>;
export type UpdateMeMutationResult = NonNullable<Awaited<ReturnType<typeof updateMe>>>;
export type UpdateMeMutationBody = BodyType<UserUpdate>;
export type UpdateMeMutationError = ErrorType<unknown>;
/**
* @summary Update current user profile
*/
export declare const useUpdateMe: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateMe>>, TError, {
        data: BodyType<UserUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof updateMe>>, TError, {
    data: BodyType<UserUpdate>;
}, TContext>;
export declare const getGetDashboardSummaryUrl: () => string;
/**
 * @summary Get dashboard summary for current user
 */
export declare const getDashboardSummary: (options?: RequestInit) => Promise<DashboardSummary>;
export declare const getGetDashboardSummaryQueryKey: () => readonly ["/api/dashboard/summary"];
export declare const getGetDashboardSummaryQueryOptions: <TData = Awaited<ReturnType<typeof getDashboardSummary>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getDashboardSummary>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getDashboardSummary>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetDashboardSummaryQueryResult = NonNullable<Awaited<ReturnType<typeof getDashboardSummary>>>;
export type GetDashboardSummaryQueryError = ErrorType<unknown>;
/**
 * @summary Get dashboard summary for current user
 */
export declare function useGetDashboardSummary<TData = Awaited<ReturnType<typeof getDashboardSummary>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getDashboardSummary>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getGetFeaturedProfilesUrl: () => string;
/**
 * @summary Get featured model profiles
 */
export declare const getFeaturedProfiles: (options?: RequestInit) => Promise<Profile[]>;
export declare const getGetFeaturedProfilesQueryKey: () => readonly ["/api/dashboard/featured-profiles"];
export declare const getGetFeaturedProfilesQueryOptions: <TData = Awaited<ReturnType<typeof getFeaturedProfiles>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getFeaturedProfiles>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getFeaturedProfiles>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetFeaturedProfilesQueryResult = NonNullable<Awaited<ReturnType<typeof getFeaturedProfiles>>>;
export type GetFeaturedProfilesQueryError = ErrorType<unknown>;
/**
 * @summary Get featured model profiles
 */
export declare function useGetFeaturedProfiles<TData = Awaited<ReturnType<typeof getFeaturedProfiles>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getFeaturedProfiles>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getGetFeaturedLocationsUrl: () => string;
/**
 * @summary Get featured locations
 */
export declare const getFeaturedLocations: (options?: RequestInit) => Promise<Location[]>;
export declare const getGetFeaturedLocationsQueryKey: () => readonly ["/api/dashboard/featured-locations"];
export declare const getGetFeaturedLocationsQueryOptions: <TData = Awaited<ReturnType<typeof getFeaturedLocations>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getFeaturedLocations>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getFeaturedLocations>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetFeaturedLocationsQueryResult = NonNullable<Awaited<ReturnType<typeof getFeaturedLocations>>>;
export type GetFeaturedLocationsQueryError = ErrorType<unknown>;
/**
 * @summary Get featured locations
 */
export declare function useGetFeaturedLocations<TData = Awaited<ReturnType<typeof getFeaturedLocations>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getFeaturedLocations>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getGetRecentActivityUrl: () => string;
/**
 * @summary Get recent booking activity for current user
 */
export declare const getRecentActivity: (options?: RequestInit) => Promise<Booking[]>;
export declare const getGetRecentActivityQueryKey: () => readonly ["/api/dashboard/recent-activity"];
export declare const getGetRecentActivityQueryOptions: <TData = Awaited<ReturnType<typeof getRecentActivity>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getRecentActivity>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getRecentActivity>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetRecentActivityQueryResult = NonNullable<Awaited<ReturnType<typeof getRecentActivity>>>;
export type GetRecentActivityQueryError = ErrorType<unknown>;
/**
 * @summary Get recent booking activity for current user
 */
export declare function useGetRecentActivity<TData = Awaited<ReturnType<typeof getRecentActivity>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getRecentActivity>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListProfilesUrl: (params?: ListProfilesParams) => string;
/**
 * @summary List all model profiles
 */
export declare const listProfiles: (params?: ListProfilesParams, options?: RequestInit) => Promise<Profile[]>;
export declare const getListProfilesQueryKey: (params?: ListProfilesParams) => readonly ["/api/profiles", ...ListProfilesParams[]];
export declare const getListProfilesQueryOptions: <TData = Awaited<ReturnType<typeof listProfiles>>, TError = ErrorType<unknown>>(params?: ListProfilesParams, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listProfiles>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listProfiles>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListProfilesQueryResult = NonNullable<Awaited<ReturnType<typeof listProfiles>>>;
export type ListProfilesQueryError = ErrorType<unknown>;
/**
 * @summary List all model profiles
 */
export declare function useListProfiles<TData = Awaited<ReturnType<typeof listProfiles>>, TError = ErrorType<unknown>>(params?: ListProfilesParams, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listProfiles>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getCreateModelApplicationUrl: () => string;
/**
 * @summary Submit a model registration application (pending admin approval)
 */
export declare const createModelApplication: (registerModelInput: RegisterModelInput, options?: RequestInit) => Promise<Profile>;
export declare const getCreateModelApplicationMutationOptions: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createModelApplication>>, TError, {
        data: BodyType<RegisterModelInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof createModelApplication>>, TError, {
    data: BodyType<RegisterModelInput>;
}, TContext>;
export type CreateModelApplicationMutationResult = NonNullable<Awaited<ReturnType<typeof createModelApplication>>>;
export type CreateModelApplicationMutationBody = BodyType<RegisterModelInput>;
export type CreateModelApplicationMutationError = ErrorType<void>;
/**
* @summary Submit a model registration application (pending admin approval)
*/
export declare const useCreateModelApplication: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createModelApplication>>, TError, {
        data: BodyType<RegisterModelInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof createModelApplication>>, TError, {
    data: BodyType<RegisterModelInput>;
}, TContext>;
export declare const getGetProfileUrl: (id: number) => string;
/**
 * @summary Get a profile by ID
 */
export declare const getProfile: (id: number, options?: RequestInit) => Promise<Profile>;
export declare const getGetProfileQueryKey: (id: number) => readonly [`/api/profiles/${number}`];
export declare const getGetProfileQueryOptions: <TData = Awaited<ReturnType<typeof getProfile>>, TError = ErrorType<void>>(id: number, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getProfile>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getProfile>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetProfileQueryResult = NonNullable<Awaited<ReturnType<typeof getProfile>>>;
export type GetProfileQueryError = ErrorType<void>;
/**
 * @summary Get a profile by ID
 */
export declare function useGetProfile<TData = Awaited<ReturnType<typeof getProfile>>, TError = ErrorType<void>>(id: number, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getProfile>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListLocationsUrl: (params?: ListLocationsParams) => string;
/**
 * @summary List all locations
 */
export declare const listLocations: (params?: ListLocationsParams, options?: RequestInit) => Promise<Location[]>;
export declare const getListLocationsQueryKey: (params?: ListLocationsParams) => readonly ["/api/locations", ...ListLocationsParams[]];
export declare const getListLocationsQueryOptions: <TData = Awaited<ReturnType<typeof listLocations>>, TError = ErrorType<unknown>>(params?: ListLocationsParams, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listLocations>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listLocations>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListLocationsQueryResult = NonNullable<Awaited<ReturnType<typeof listLocations>>>;
export type ListLocationsQueryError = ErrorType<unknown>;
/**
 * @summary List all locations
 */
export declare function useListLocations<TData = Awaited<ReturnType<typeof listLocations>>, TError = ErrorType<unknown>>(params?: ListLocationsParams, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listLocations>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getGetLocationUrl: (id: number) => string;
/**
 * @summary Get a location by ID
 */
export declare const getLocation: (id: number, options?: RequestInit) => Promise<Location>;
export declare const getGetLocationQueryKey: (id: number) => readonly [`/api/locations/${number}`];
export declare const getGetLocationQueryOptions: <TData = Awaited<ReturnType<typeof getLocation>>, TError = ErrorType<void>>(id: number, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getLocation>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getLocation>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetLocationQueryResult = NonNullable<Awaited<ReturnType<typeof getLocation>>>;
export type GetLocationQueryError = ErrorType<void>;
/**
 * @summary Get a location by ID
 */
export declare function useGetLocation<TData = Awaited<ReturnType<typeof getLocation>>, TError = ErrorType<void>>(id: number, options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getLocation>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListServicesUrl: () => string;
/**
 * @summary List bookable services
 */
export declare const listServices: (options?: RequestInit) => Promise<Service[]>;
export declare const getListServicesQueryKey: () => readonly ["/api/services"];
export declare const getListServicesQueryOptions: <TData = Awaited<ReturnType<typeof listServices>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listServices>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listServices>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListServicesQueryResult = NonNullable<Awaited<ReturnType<typeof listServices>>>;
export type ListServicesQueryError = ErrorType<unknown>;
/**
 * @summary List bookable services
 */
export declare function useListServices<TData = Awaited<ReturnType<typeof listServices>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listServices>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListMyBookingsUrl: () => string;
/**
 * @summary List current user's bookings
 */
export declare const listMyBookings: (options?: RequestInit) => Promise<Booking[]>;
export declare const getListMyBookingsQueryKey: () => readonly ["/api/bookings"];
export declare const getListMyBookingsQueryOptions: <TData = Awaited<ReturnType<typeof listMyBookings>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyBookings>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listMyBookings>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListMyBookingsQueryResult = NonNullable<Awaited<ReturnType<typeof listMyBookings>>>;
export type ListMyBookingsQueryError = ErrorType<unknown>;
/**
 * @summary List current user's bookings
 */
export declare function useListMyBookings<TData = Awaited<ReturnType<typeof listMyBookings>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyBookings>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getCreateBookingUrl: () => string;
/**
 * @summary Create a booking
 */
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
*/
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 a booking by ID
 */
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 a booking by ID
 */
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 getCancelBookingUrl: (id: number) => string;
/**
 * @summary Cancel a booking
 */
export declare const cancelBooking: (id: number, options?: RequestInit) => Promise<void>;
export declare const getCancelBookingMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof cancelBooking>>, TError, {
        id: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof cancelBooking>>, TError, {
    id: number;
}, TContext>;
export type CancelBookingMutationResult = NonNullable<Awaited<ReturnType<typeof cancelBooking>>>;
export type CancelBookingMutationError = ErrorType<unknown>;
/**
* @summary Cancel a booking
*/
export declare const useCancelBooking: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof cancelBooking>>, TError, {
        id: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof cancelBooking>>, TError, {
    id: number;
}, TContext>;
export declare const getGetMyMembershipUrl: () => string;
/**
 * @summary Get current user's membership
 */
export declare const getMyMembership: (options?: RequestInit) => Promise<Membership>;
export declare const getGetMyMembershipQueryKey: () => readonly ["/api/memberships/my"];
export declare const getGetMyMembershipQueryOptions: <TData = Awaited<ReturnType<typeof getMyMembership>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getMyMembership>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getMyMembership>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetMyMembershipQueryResult = NonNullable<Awaited<ReturnType<typeof getMyMembership>>>;
export type GetMyMembershipQueryError = ErrorType<unknown>;
/**
 * @summary Get current user's membership
 */
export declare function useGetMyMembership<TData = Awaited<ReturnType<typeof getMyMembership>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getMyMembership>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListMembershipTiersUrl: () => string;
/**
 * @summary List available membership plans
 */
export declare const listMembershipTiers: (options?: RequestInit) => Promise<MembershipPlan[]>;
export declare const getListMembershipTiersQueryKey: () => readonly ["/api/memberships/tiers"];
export declare const getListMembershipTiersQueryOptions: <TData = Awaited<ReturnType<typeof listMembershipTiers>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMembershipTiers>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listMembershipTiers>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListMembershipTiersQueryResult = NonNullable<Awaited<ReturnType<typeof listMembershipTiers>>>;
export type ListMembershipTiersQueryError = ErrorType<unknown>;
/**
 * @summary List available membership plans
 */
export declare function useListMembershipTiers<TData = Awaited<ReturnType<typeof listMembershipTiers>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMembershipTiers>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListPaymentMethodsUrl: () => string;
/**
 * @summary List active payment methods
 */
export declare const listPaymentMethods: (options?: RequestInit) => Promise<PaymentMethod[]>;
export declare const getListPaymentMethodsQueryKey: () => readonly ["/api/memberships/payment-methods"];
export declare const getListPaymentMethodsQueryOptions: <TData = Awaited<ReturnType<typeof listPaymentMethods>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listPaymentMethods>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listPaymentMethods>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListPaymentMethodsQueryResult = NonNullable<Awaited<ReturnType<typeof listPaymentMethods>>>;
export type ListPaymentMethodsQueryError = ErrorType<unknown>;
/**
 * @summary List active payment methods
 */
export declare function useListPaymentMethods<TData = Awaited<ReturnType<typeof listPaymentMethods>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listPaymentMethods>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getSubscribeMembershipUrl: () => string;
/**
 * @summary Submit a membership payment for verification
 */
export declare const subscribeMembership: (subscribeInput: SubscribeInput, options?: RequestInit) => Promise<MembershipPayment>;
export declare const getSubscribeMembershipMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof subscribeMembership>>, TError, {
        data: BodyType<SubscribeInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof subscribeMembership>>, TError, {
    data: BodyType<SubscribeInput>;
}, TContext>;
export type SubscribeMembershipMutationResult = NonNullable<Awaited<ReturnType<typeof subscribeMembership>>>;
export type SubscribeMembershipMutationBody = BodyType<SubscribeInput>;
export type SubscribeMembershipMutationError = ErrorType<unknown>;
/**
* @summary Submit a membership payment for verification
*/
export declare const useSubscribeMembership: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof subscribeMembership>>, TError, {
        data: BodyType<SubscribeInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof subscribeMembership>>, TError, {
    data: BodyType<SubscribeInput>;
}, TContext>;
export declare const getListMyMembershipPaymentsUrl: () => string;
/**
 * @summary List current user's membership payment submissions
 */
export declare const listMyMembershipPayments: (options?: RequestInit) => Promise<MembershipPayment[]>;
export declare const getListMyMembershipPaymentsQueryKey: () => readonly ["/api/memberships/my-payments"];
export declare const getListMyMembershipPaymentsQueryOptions: <TData = Awaited<ReturnType<typeof listMyMembershipPayments>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyMembershipPayments>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listMyMembershipPayments>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListMyMembershipPaymentsQueryResult = NonNullable<Awaited<ReturnType<typeof listMyMembershipPayments>>>;
export type ListMyMembershipPaymentsQueryError = ErrorType<unknown>;
/**
 * @summary List current user's membership payment submissions
 */
export declare function useListMyMembershipPayments<TData = Awaited<ReturnType<typeof listMyMembershipPayments>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyMembershipPayments>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListNetworkMembersUrl: () => string;
/**
 * @summary List network members (other users in the platform)
 */
export declare const listNetworkMembers: (options?: RequestInit) => Promise<NetworkMember[]>;
export declare const getListNetworkMembersQueryKey: () => readonly ["/api/network/members"];
export declare const getListNetworkMembersQueryOptions: <TData = Awaited<ReturnType<typeof listNetworkMembers>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listNetworkMembers>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listNetworkMembers>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListNetworkMembersQueryResult = NonNullable<Awaited<ReturnType<typeof listNetworkMembers>>>;
export type ListNetworkMembersQueryError = ErrorType<unknown>;
/**
 * @summary List network members (other users in the platform)
 */
export declare function useListNetworkMembers<TData = Awaited<ReturnType<typeof listNetworkMembers>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listNetworkMembers>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListAssetsUrl: () => string;
/**
 * @summary List platform assets (resources, links, tools)
 */
export declare const listAssets: (options?: RequestInit) => Promise<Asset[]>;
export declare const getListAssetsQueryKey: () => readonly ["/api/assets"];
export declare const getListAssetsQueryOptions: <TData = Awaited<ReturnType<typeof listAssets>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listAssets>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listAssets>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListAssetsQueryResult = NonNullable<Awaited<ReturnType<typeof listAssets>>>;
export type ListAssetsQueryError = ErrorType<unknown>;
/**
 * @summary List platform assets (resources, links, tools)
 */
export declare function useListAssets<TData = Awaited<ReturnType<typeof listAssets>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listAssets>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminListProfilesUrl: () => string;
/**
 * @summary Admin — list all profiles
 */
export declare const adminListProfiles: (options?: RequestInit) => Promise<Profile[]>;
export declare const getAdminListProfilesQueryKey: () => readonly ["/api/admin/profiles"];
export declare const getAdminListProfilesQueryOptions: <TData = Awaited<ReturnType<typeof adminListProfiles>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListProfiles>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListProfiles>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListProfilesQueryResult = NonNullable<Awaited<ReturnType<typeof adminListProfiles>>>;
export type AdminListProfilesQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all profiles
 */
export declare function useAdminListProfiles<TData = Awaited<ReturnType<typeof adminListProfiles>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListProfiles>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminCreateProfileUrl: () => string;
/**
 * @summary Admin — create a profile
 */
export declare const adminCreateProfile: (profileInput: ProfileInput, options?: RequestInit) => Promise<Profile>;
export declare const getAdminCreateProfileMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminCreateProfile>>, TError, {
        data: BodyType<ProfileInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminCreateProfile>>, TError, {
    data: BodyType<ProfileInput>;
}, TContext>;
export type AdminCreateProfileMutationResult = NonNullable<Awaited<ReturnType<typeof adminCreateProfile>>>;
export type AdminCreateProfileMutationBody = BodyType<ProfileInput>;
export type AdminCreateProfileMutationError = ErrorType<unknown>;
/**
* @summary Admin — create a profile
*/
export declare const useAdminCreateProfile: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminCreateProfile>>, TError, {
        data: BodyType<ProfileInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminCreateProfile>>, TError, {
    data: BodyType<ProfileInput>;
}, TContext>;
export declare const getAdminUpdateProfileUrl: (id: number) => string;
/**
 * @summary Admin — update a profile
 */
export declare const adminUpdateProfile: (id: number, profileUpdate: ProfileUpdate, options?: RequestInit) => Promise<Profile>;
export declare const getAdminUpdateProfileMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminUpdateProfile>>, TError, {
        id: number;
        data: BodyType<ProfileUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminUpdateProfile>>, TError, {
    id: number;
    data: BodyType<ProfileUpdate>;
}, TContext>;
export type AdminUpdateProfileMutationResult = NonNullable<Awaited<ReturnType<typeof adminUpdateProfile>>>;
export type AdminUpdateProfileMutationBody = BodyType<ProfileUpdate>;
export type AdminUpdateProfileMutationError = ErrorType<unknown>;
/**
* @summary Admin — update a profile
*/
export declare const useAdminUpdateProfile: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminUpdateProfile>>, TError, {
        id: number;
        data: BodyType<ProfileUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminUpdateProfile>>, TError, {
    id: number;
    data: BodyType<ProfileUpdate>;
}, TContext>;
export declare const getAdminDeleteProfileUrl: (id: number) => string;
/**
 * @summary Admin — delete a profile
 */
export declare const adminDeleteProfile: (id: number, options?: RequestInit) => Promise<void>;
export declare const getAdminDeleteProfileMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminDeleteProfile>>, TError, {
        id: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminDeleteProfile>>, TError, {
    id: number;
}, TContext>;
export type AdminDeleteProfileMutationResult = NonNullable<Awaited<ReturnType<typeof adminDeleteProfile>>>;
export type AdminDeleteProfileMutationError = ErrorType<unknown>;
/**
* @summary Admin — delete a profile
*/
export declare const useAdminDeleteProfile: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminDeleteProfile>>, TError, {
        id: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminDeleteProfile>>, TError, {
    id: number;
}, TContext>;
export declare const getAdminListLocationsUrl: () => string;
/**
 * @summary Admin — list all locations
 */
export declare const adminListLocations: (options?: RequestInit) => Promise<Location[]>;
export declare const getAdminListLocationsQueryKey: () => readonly ["/api/admin/locations"];
export declare const getAdminListLocationsQueryOptions: <TData = Awaited<ReturnType<typeof adminListLocations>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListLocations>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListLocations>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListLocationsQueryResult = NonNullable<Awaited<ReturnType<typeof adminListLocations>>>;
export type AdminListLocationsQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all locations
 */
export declare function useAdminListLocations<TData = Awaited<ReturnType<typeof adminListLocations>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListLocations>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminCreateLocationUrl: () => string;
/**
 * @summary Admin — create a location
 */
export declare const adminCreateLocation: (locationInput: LocationInput, options?: RequestInit) => Promise<Location>;
export declare const getAdminCreateLocationMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminCreateLocation>>, TError, {
        data: BodyType<LocationInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminCreateLocation>>, TError, {
    data: BodyType<LocationInput>;
}, TContext>;
export type AdminCreateLocationMutationResult = NonNullable<Awaited<ReturnType<typeof adminCreateLocation>>>;
export type AdminCreateLocationMutationBody = BodyType<LocationInput>;
export type AdminCreateLocationMutationError = ErrorType<unknown>;
/**
* @summary Admin — create a location
*/
export declare const useAdminCreateLocation: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminCreateLocation>>, TError, {
        data: BodyType<LocationInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminCreateLocation>>, TError, {
    data: BodyType<LocationInput>;
}, TContext>;
export declare const getAdminUpdateLocationUrl: (id: number) => string;
/**
 * @summary Admin — update a location
 */
export declare const adminUpdateLocation: (id: number, locationUpdate: LocationUpdate, options?: RequestInit) => Promise<Location>;
export declare const getAdminUpdateLocationMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminUpdateLocation>>, TError, {
        id: number;
        data: BodyType<LocationUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminUpdateLocation>>, TError, {
    id: number;
    data: BodyType<LocationUpdate>;
}, TContext>;
export type AdminUpdateLocationMutationResult = NonNullable<Awaited<ReturnType<typeof adminUpdateLocation>>>;
export type AdminUpdateLocationMutationBody = BodyType<LocationUpdate>;
export type AdminUpdateLocationMutationError = ErrorType<unknown>;
/**
* @summary Admin — update a location
*/
export declare const useAdminUpdateLocation: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminUpdateLocation>>, TError, {
        id: number;
        data: BodyType<LocationUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminUpdateLocation>>, TError, {
    id: number;
    data: BodyType<LocationUpdate>;
}, TContext>;
export declare const getAdminDeleteLocationUrl: (id: number) => string;
/**
 * @summary Admin — delete a location
 */
export declare const adminDeleteLocation: (id: number, options?: RequestInit) => Promise<void>;
export declare const getAdminDeleteLocationMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminDeleteLocation>>, TError, {
        id: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminDeleteLocation>>, TError, {
    id: number;
}, TContext>;
export type AdminDeleteLocationMutationResult = NonNullable<Awaited<ReturnType<typeof adminDeleteLocation>>>;
export type AdminDeleteLocationMutationError = ErrorType<unknown>;
/**
* @summary Admin — delete a location
*/
export declare const useAdminDeleteLocation: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminDeleteLocation>>, TError, {
        id: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminDeleteLocation>>, TError, {
    id: number;
}, TContext>;
export declare const getAdminListMembershipsUrl: () => string;
/**
 * @summary Admin — list all user memberships
 */
export declare const adminListMemberships: (options?: RequestInit) => Promise<Membership[]>;
export declare const getAdminListMembershipsQueryKey: () => readonly ["/api/admin/memberships"];
export declare const getAdminListMembershipsQueryOptions: <TData = Awaited<ReturnType<typeof adminListMemberships>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListMemberships>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListMemberships>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListMembershipsQueryResult = NonNullable<Awaited<ReturnType<typeof adminListMemberships>>>;
export type AdminListMembershipsQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all user memberships
 */
export declare function useAdminListMemberships<TData = Awaited<ReturnType<typeof adminListMemberships>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListMemberships>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminUpdateMembershipUrl: (userId: number) => string;
/**
 * @summary Admin — update a user's membership tier
 */
export declare const adminUpdateMembership: (userId: number, membershipUpdate: MembershipUpdate, options?: RequestInit) => Promise<Membership>;
export declare const getAdminUpdateMembershipMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminUpdateMembership>>, TError, {
        userId: number;
        data: BodyType<MembershipUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminUpdateMembership>>, TError, {
    userId: number;
    data: BodyType<MembershipUpdate>;
}, TContext>;
export type AdminUpdateMembershipMutationResult = NonNullable<Awaited<ReturnType<typeof adminUpdateMembership>>>;
export type AdminUpdateMembershipMutationBody = BodyType<MembershipUpdate>;
export type AdminUpdateMembershipMutationError = ErrorType<unknown>;
/**
* @summary Admin — update a user's membership tier
*/
export declare const useAdminUpdateMembership: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminUpdateMembership>>, TError, {
        userId: number;
        data: BodyType<MembershipUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminUpdateMembership>>, TError, {
    userId: number;
    data: BodyType<MembershipUpdate>;
}, TContext>;
export declare const getAdminListMembershipPlansUrl: () => string;
/**
 * @summary Admin — list all membership plans
 */
export declare const adminListMembershipPlans: (options?: RequestInit) => Promise<MembershipPlan[]>;
export declare const getAdminListMembershipPlansQueryKey: () => readonly ["/api/admin/membership-plans"];
export declare const getAdminListMembershipPlansQueryOptions: <TData = Awaited<ReturnType<typeof adminListMembershipPlans>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListMembershipPlans>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListMembershipPlans>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListMembershipPlansQueryResult = NonNullable<Awaited<ReturnType<typeof adminListMembershipPlans>>>;
export type AdminListMembershipPlansQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all membership plans
 */
export declare function useAdminListMembershipPlans<TData = Awaited<ReturnType<typeof adminListMembershipPlans>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListMembershipPlans>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminCreateMembershipPlanUrl: () => string;
/**
 * @summary Admin — create a membership plan
 */
export declare const adminCreateMembershipPlan: (membershipPlanInput: MembershipPlanInput, options?: RequestInit) => Promise<MembershipPlan>;
export declare const getAdminCreateMembershipPlanMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminCreateMembershipPlan>>, TError, {
        data: BodyType<MembershipPlanInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminCreateMembershipPlan>>, TError, {
    data: BodyType<MembershipPlanInput>;
}, TContext>;
export type AdminCreateMembershipPlanMutationResult = NonNullable<Awaited<ReturnType<typeof adminCreateMembershipPlan>>>;
export type AdminCreateMembershipPlanMutationBody = BodyType<MembershipPlanInput>;
export type AdminCreateMembershipPlanMutationError = ErrorType<unknown>;
/**
* @summary Admin — create a membership plan
*/
export declare const useAdminCreateMembershipPlan: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminCreateMembershipPlan>>, TError, {
        data: BodyType<MembershipPlanInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminCreateMembershipPlan>>, TError, {
    data: BodyType<MembershipPlanInput>;
}, TContext>;
export declare const getAdminUpdateMembershipPlanUrl: (id: number) => string;
/**
 * @summary Admin — update a membership plan
 */
export declare const adminUpdateMembershipPlan: (id: number, membershipPlanUpdate: MembershipPlanUpdate, options?: RequestInit) => Promise<MembershipPlan>;
export declare const getAdminUpdateMembershipPlanMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminUpdateMembershipPlan>>, TError, {
        id: number;
        data: BodyType<MembershipPlanUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminUpdateMembershipPlan>>, TError, {
    id: number;
    data: BodyType<MembershipPlanUpdate>;
}, TContext>;
export type AdminUpdateMembershipPlanMutationResult = NonNullable<Awaited<ReturnType<typeof adminUpdateMembershipPlan>>>;
export type AdminUpdateMembershipPlanMutationBody = BodyType<MembershipPlanUpdate>;
export type AdminUpdateMembershipPlanMutationError = ErrorType<unknown>;
/**
* @summary Admin — update a membership plan
*/
export declare const useAdminUpdateMembershipPlan: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminUpdateMembershipPlan>>, TError, {
        id: number;
        data: BodyType<MembershipPlanUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminUpdateMembershipPlan>>, TError, {
    id: number;
    data: BodyType<MembershipPlanUpdate>;
}, TContext>;
export declare const getAdminDeleteMembershipPlanUrl: (id: number) => string;
/**
 * @summary Admin — delete a membership plan
 */
export declare const adminDeleteMembershipPlan: (id: number, options?: RequestInit) => Promise<void>;
export declare const getAdminDeleteMembershipPlanMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminDeleteMembershipPlan>>, TError, {
        id: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminDeleteMembershipPlan>>, TError, {
    id: number;
}, TContext>;
export type AdminDeleteMembershipPlanMutationResult = NonNullable<Awaited<ReturnType<typeof adminDeleteMembershipPlan>>>;
export type AdminDeleteMembershipPlanMutationError = ErrorType<unknown>;
/**
* @summary Admin — delete a membership plan
*/
export declare const useAdminDeleteMembershipPlan: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminDeleteMembershipPlan>>, TError, {
        id: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminDeleteMembershipPlan>>, TError, {
    id: number;
}, TContext>;
export declare const getAdminListPaymentMethodsUrl: () => string;
/**
 * @summary Admin — list all payment methods
 */
export declare const adminListPaymentMethods: (options?: RequestInit) => Promise<PaymentMethod[]>;
export declare const getAdminListPaymentMethodsQueryKey: () => readonly ["/api/admin/payment-methods"];
export declare const getAdminListPaymentMethodsQueryOptions: <TData = Awaited<ReturnType<typeof adminListPaymentMethods>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListPaymentMethods>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListPaymentMethods>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListPaymentMethodsQueryResult = NonNullable<Awaited<ReturnType<typeof adminListPaymentMethods>>>;
export type AdminListPaymentMethodsQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all payment methods
 */
export declare function useAdminListPaymentMethods<TData = Awaited<ReturnType<typeof adminListPaymentMethods>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListPaymentMethods>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminUpdatePaymentMethodUrl: (id: number) => string;
/**
 * @summary Admin — update a payment method
 */
export declare const adminUpdatePaymentMethod: (id: number, paymentMethodUpdate: PaymentMethodUpdate, options?: RequestInit) => Promise<PaymentMethod>;
export declare const getAdminUpdatePaymentMethodMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminUpdatePaymentMethod>>, TError, {
        id: number;
        data: BodyType<PaymentMethodUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminUpdatePaymentMethod>>, TError, {
    id: number;
    data: BodyType<PaymentMethodUpdate>;
}, TContext>;
export type AdminUpdatePaymentMethodMutationResult = NonNullable<Awaited<ReturnType<typeof adminUpdatePaymentMethod>>>;
export type AdminUpdatePaymentMethodMutationBody = BodyType<PaymentMethodUpdate>;
export type AdminUpdatePaymentMethodMutationError = ErrorType<unknown>;
/**
* @summary Admin — update a payment method
*/
export declare const useAdminUpdatePaymentMethod: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminUpdatePaymentMethod>>, TError, {
        id: number;
        data: BodyType<PaymentMethodUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminUpdatePaymentMethod>>, TError, {
    id: number;
    data: BodyType<PaymentMethodUpdate>;
}, TContext>;
export declare const getAdminListMembershipPaymentsUrl: () => string;
/**
 * @summary Admin — list all membership payment submissions
 */
export declare const adminListMembershipPayments: (options?: RequestInit) => Promise<MembershipPayment[]>;
export declare const getAdminListMembershipPaymentsQueryKey: () => readonly ["/api/admin/membership-payments"];
export declare const getAdminListMembershipPaymentsQueryOptions: <TData = Awaited<ReturnType<typeof adminListMembershipPayments>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListMembershipPayments>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListMembershipPayments>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListMembershipPaymentsQueryResult = NonNullable<Awaited<ReturnType<typeof adminListMembershipPayments>>>;
export type AdminListMembershipPaymentsQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all membership payment submissions
 */
export declare function useAdminListMembershipPayments<TData = Awaited<ReturnType<typeof adminListMembershipPayments>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListMembershipPayments>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminReviewMembershipPaymentUrl: (id: number) => string;
/**
 * @summary Admin — approve or reject a membership payment
 */
export declare const adminReviewMembershipPayment: (id: number, membershipPaymentReview: MembershipPaymentReview, options?: RequestInit) => Promise<MembershipPayment>;
export declare const getAdminReviewMembershipPaymentMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminReviewMembershipPayment>>, TError, {
        id: number;
        data: BodyType<MembershipPaymentReview>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminReviewMembershipPayment>>, TError, {
    id: number;
    data: BodyType<MembershipPaymentReview>;
}, TContext>;
export type AdminReviewMembershipPaymentMutationResult = NonNullable<Awaited<ReturnType<typeof adminReviewMembershipPayment>>>;
export type AdminReviewMembershipPaymentMutationBody = BodyType<MembershipPaymentReview>;
export type AdminReviewMembershipPaymentMutationError = ErrorType<unknown>;
/**
* @summary Admin — approve or reject a membership payment
*/
export declare const useAdminReviewMembershipPayment: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminReviewMembershipPayment>>, TError, {
        id: number;
        data: BodyType<MembershipPaymentReview>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminReviewMembershipPayment>>, TError, {
    id: number;
    data: BodyType<MembershipPaymentReview>;
}, TContext>;
export declare const getAdminListBookingsUrl: () => string;
/**
 * @summary Admin — list all bookings
 */
export declare const adminListBookings: (options?: RequestInit) => Promise<Booking[]>;
export declare const getAdminListBookingsQueryKey: () => readonly ["/api/admin/bookings"];
export declare const getAdminListBookingsQueryOptions: <TData = Awaited<ReturnType<typeof adminListBookings>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListBookings>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListBookings>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListBookingsQueryResult = NonNullable<Awaited<ReturnType<typeof adminListBookings>>>;
export type AdminListBookingsQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all bookings
 */
export declare function useAdminListBookings<TData = Awaited<ReturnType<typeof adminListBookings>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListBookings>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminListUsersUrl: () => string;
/**
 * @summary Admin — list all users
 */
export declare const adminListUsers: (options?: RequestInit) => Promise<User[]>;
export declare const getAdminListUsersQueryKey: () => readonly ["/api/admin/users"];
export declare const getAdminListUsersQueryOptions: <TData = Awaited<ReturnType<typeof adminListUsers>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListUsers>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListUsers>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListUsersQueryResult = NonNullable<Awaited<ReturnType<typeof adminListUsers>>>;
export type AdminListUsersQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all users
 */
export declare function useAdminListUsers<TData = Awaited<ReturnType<typeof adminListUsers>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListUsers>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getUpdateBookingStatusUrl: (id: number) => string;
/**
 * @summary Update a booking's status (role-aware transition)
 */
export declare const updateBookingStatus: (id: number, bookingStatusInput: BookingStatusInput, 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<BookingStatusInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof updateBookingStatus>>, TError, {
    id: number;
    data: BodyType<BookingStatusInput>;
}, TContext>;
export type UpdateBookingStatusMutationResult = NonNullable<Awaited<ReturnType<typeof updateBookingStatus>>>;
export type UpdateBookingStatusMutationBody = BodyType<BookingStatusInput>;
export type UpdateBookingStatusMutationError = ErrorType<unknown>;
/**
* @summary Update a booking's status (role-aware transition)
*/
export declare const useUpdateBookingStatus: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateBookingStatus>>, TError, {
        id: number;
        data: BodyType<BookingStatusInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof updateBookingStatus>>, TError, {
    id: number;
    data: BodyType<BookingStatusInput>;
}, TContext>;
export declare const getUploadBookingProofUrl: (id: number) => string;
/**
 * @summary Model uploads a proof-of-completion photo for a paid order
 */
export declare const uploadBookingProof: (id: number, proofUploadInput: ProofUploadInput, options?: RequestInit) => Promise<Booking>;
export declare const getUploadBookingProofMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof uploadBookingProof>>, TError, {
        id: number;
        data: BodyType<ProofUploadInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof uploadBookingProof>>, TError, {
    id: number;
    data: BodyType<ProofUploadInput>;
}, TContext>;
export type UploadBookingProofMutationResult = NonNullable<Awaited<ReturnType<typeof uploadBookingProof>>>;
export type UploadBookingProofMutationBody = BodyType<ProofUploadInput>;
export type UploadBookingProofMutationError = ErrorType<unknown>;
/**
* @summary Model uploads a proof-of-completion photo for a paid order
*/
export declare const useUploadBookingProof: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof uploadBookingProof>>, TError, {
        id: number;
        data: BodyType<ProofUploadInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof uploadBookingProof>>, TError, {
    id: number;
    data: BodyType<ProofUploadInput>;
}, TContext>;
export declare const getGetWalletUrl: () => string;
/**
 * @summary Get current user's wallet balance and recent transactions
 */
export declare const getWallet: (options?: RequestInit) => Promise<Wallet>;
export declare const getGetWalletQueryKey: () => readonly ["/api/wallet"];
export declare const getGetWalletQueryOptions: <TData = Awaited<ReturnType<typeof getWallet>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getWallet>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getWallet>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetWalletQueryResult = NonNullable<Awaited<ReturnType<typeof getWallet>>>;
export type GetWalletQueryError = ErrorType<unknown>;
/**
 * @summary Get current user's wallet balance and recent transactions
 */
export declare function useGetWallet<TData = Awaited<ReturnType<typeof getWallet>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getWallet>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListWalletTransactionsUrl: () => string;
/**
 * @summary List all of the current user's wallet transactions
 */
export declare const listWalletTransactions: (options?: RequestInit) => Promise<WalletTransaction[]>;
export declare const getListWalletTransactionsQueryKey: () => readonly ["/api/wallet/transactions"];
export declare const getListWalletTransactionsQueryOptions: <TData = Awaited<ReturnType<typeof listWalletTransactions>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listWalletTransactions>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listWalletTransactions>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListWalletTransactionsQueryResult = NonNullable<Awaited<ReturnType<typeof listWalletTransactions>>>;
export type ListWalletTransactionsQueryError = ErrorType<unknown>;
/**
 * @summary List all of the current user's wallet transactions
 */
export declare function useListWalletTransactions<TData = Awaited<ReturnType<typeof listWalletTransactions>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listWalletTransactions>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListMyDepositsUrl: () => string;
/**
 * @summary List current user's deposit requests
 */
export declare const listMyDeposits: (options?: RequestInit) => Promise<WalletDeposit[]>;
export declare const getListMyDepositsQueryKey: () => readonly ["/api/wallet/deposits"];
export declare const getListMyDepositsQueryOptions: <TData = Awaited<ReturnType<typeof listMyDeposits>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyDeposits>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listMyDeposits>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListMyDepositsQueryResult = NonNullable<Awaited<ReturnType<typeof listMyDeposits>>>;
export type ListMyDepositsQueryError = ErrorType<unknown>;
/**
 * @summary List current user's deposit requests
 */
export declare function useListMyDeposits<TData = Awaited<ReturnType<typeof listMyDeposits>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyDeposits>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getCreateDepositUrl: () => string;
/**
 * @summary Submit a wallet deposit request
 */
export declare const createDeposit: (depositInput: DepositInput, options?: RequestInit) => Promise<WalletDeposit>;
export declare const getCreateDepositMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createDeposit>>, TError, {
        data: BodyType<DepositInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof createDeposit>>, TError, {
    data: BodyType<DepositInput>;
}, TContext>;
export type CreateDepositMutationResult = NonNullable<Awaited<ReturnType<typeof createDeposit>>>;
export type CreateDepositMutationBody = BodyType<DepositInput>;
export type CreateDepositMutationError = ErrorType<unknown>;
/**
* @summary Submit a wallet deposit request
*/
export declare const useCreateDeposit: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createDeposit>>, TError, {
        data: BodyType<DepositInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof createDeposit>>, TError, {
    data: BodyType<DepositInput>;
}, TContext>;
export declare const getListMyWithdrawalsUrl: () => string;
/**
 * @summary List current user's withdrawal requests
 */
export declare const listMyWithdrawals: (options?: RequestInit) => Promise<Withdrawal[]>;
export declare const getListMyWithdrawalsQueryKey: () => readonly ["/api/wallet/withdrawals"];
export declare const getListMyWithdrawalsQueryOptions: <TData = Awaited<ReturnType<typeof listMyWithdrawals>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyWithdrawals>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listMyWithdrawals>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListMyWithdrawalsQueryResult = NonNullable<Awaited<ReturnType<typeof listMyWithdrawals>>>;
export type ListMyWithdrawalsQueryError = ErrorType<unknown>;
/**
 * @summary List current user's withdrawal requests
 */
export declare function useListMyWithdrawals<TData = Awaited<ReturnType<typeof listMyWithdrawals>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyWithdrawals>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getCreateWithdrawalUrl: () => string;
/**
 * @summary Request a payout (model only)
 */
export declare const createWithdrawal: (withdrawalInput: WithdrawalInput, options?: RequestInit) => Promise<Withdrawal>;
export declare const getCreateWithdrawalMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createWithdrawal>>, TError, {
        data: BodyType<WithdrawalInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof createWithdrawal>>, TError, {
    data: BodyType<WithdrawalInput>;
}, TContext>;
export type CreateWithdrawalMutationResult = NonNullable<Awaited<ReturnType<typeof createWithdrawal>>>;
export type CreateWithdrawalMutationBody = BodyType<WithdrawalInput>;
export type CreateWithdrawalMutationError = ErrorType<unknown>;
/**
* @summary Request a payout (model only)
*/
export declare const useCreateWithdrawal: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createWithdrawal>>, TError, {
        data: BodyType<WithdrawalInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof createWithdrawal>>, TError, {
    data: BodyType<WithdrawalInput>;
}, TContext>;
export declare const getAdminListWalletsUrl: () => string;
/**
 * @summary Admin — list all wallets
 */
export declare const adminListWallets: (options?: RequestInit) => Promise<AdminWallet[]>;
export declare const getAdminListWalletsQueryKey: () => readonly ["/api/admin/wallets"];
export declare const getAdminListWalletsQueryOptions: <TData = Awaited<ReturnType<typeof adminListWallets>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListWallets>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListWallets>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListWalletsQueryResult = NonNullable<Awaited<ReturnType<typeof adminListWallets>>>;
export type AdminListWalletsQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all wallets
 */
export declare function useAdminListWallets<TData = Awaited<ReturnType<typeof adminListWallets>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListWallets>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminCreditWalletUrl: (userId: number) => string;
/**
 * @summary Admin — credit (or debit) a user's wallet
 */
export declare const adminCreditWallet: (userId: number, walletCreditInput: WalletCreditInput, options?: RequestInit) => Promise<AdminWallet>;
export declare const getAdminCreditWalletMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminCreditWallet>>, TError, {
        userId: number;
        data: BodyType<WalletCreditInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminCreditWallet>>, TError, {
    userId: number;
    data: BodyType<WalletCreditInput>;
}, TContext>;
export type AdminCreditWalletMutationResult = NonNullable<Awaited<ReturnType<typeof adminCreditWallet>>>;
export type AdminCreditWalletMutationBody = BodyType<WalletCreditInput>;
export type AdminCreditWalletMutationError = ErrorType<unknown>;
/**
* @summary Admin — credit (or debit) a user's wallet
*/
export declare const useAdminCreditWallet: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminCreditWallet>>, TError, {
        userId: number;
        data: BodyType<WalletCreditInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminCreditWallet>>, TError, {
    userId: number;
    data: BodyType<WalletCreditInput>;
}, TContext>;
export declare const getAdminListDepositsUrl: () => string;
/**
 * @summary Admin — list all deposit requests
 */
export declare const adminListDeposits: (options?: RequestInit) => Promise<WalletDeposit[]>;
export declare const getAdminListDepositsQueryKey: () => readonly ["/api/admin/deposits"];
export declare const getAdminListDepositsQueryOptions: <TData = Awaited<ReturnType<typeof adminListDeposits>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListDeposits>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListDeposits>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListDepositsQueryResult = NonNullable<Awaited<ReturnType<typeof adminListDeposits>>>;
export type AdminListDepositsQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all deposit requests
 */
export declare function useAdminListDeposits<TData = Awaited<ReturnType<typeof adminListDeposits>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListDeposits>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminReviewDepositUrl: (id: number) => string;
/**
 * @summary Admin — approve or reject a deposit request
 */
export declare const adminReviewDeposit: (id: number, walletReview: WalletReview, options?: RequestInit) => Promise<WalletDeposit>;
export declare const getAdminReviewDepositMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminReviewDeposit>>, TError, {
        id: number;
        data: BodyType<WalletReview>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminReviewDeposit>>, TError, {
    id: number;
    data: BodyType<WalletReview>;
}, TContext>;
export type AdminReviewDepositMutationResult = NonNullable<Awaited<ReturnType<typeof adminReviewDeposit>>>;
export type AdminReviewDepositMutationBody = BodyType<WalletReview>;
export type AdminReviewDepositMutationError = ErrorType<unknown>;
/**
* @summary Admin — approve or reject a deposit request
*/
export declare const useAdminReviewDeposit: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminReviewDeposit>>, TError, {
        id: number;
        data: BodyType<WalletReview>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminReviewDeposit>>, TError, {
    id: number;
    data: BodyType<WalletReview>;
}, TContext>;
export declare const getAdminListWithdrawalsUrl: () => string;
/**
 * @summary Admin — list all withdrawal requests
 */
export declare const adminListWithdrawals: (options?: RequestInit) => Promise<Withdrawal[]>;
export declare const getAdminListWithdrawalsQueryKey: () => readonly ["/api/admin/withdrawals"];
export declare const getAdminListWithdrawalsQueryOptions: <TData = Awaited<ReturnType<typeof adminListWithdrawals>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListWithdrawals>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListWithdrawals>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListWithdrawalsQueryResult = NonNullable<Awaited<ReturnType<typeof adminListWithdrawals>>>;
export type AdminListWithdrawalsQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list all withdrawal requests
 */
export declare function useAdminListWithdrawals<TData = Awaited<ReturnType<typeof adminListWithdrawals>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListWithdrawals>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminReviewWithdrawalUrl: (id: number) => string;
/**
 * @summary Admin — approve or reject a withdrawal request
 */
export declare const adminReviewWithdrawal: (id: number, walletReview: WalletReview, options?: RequestInit) => Promise<Withdrawal>;
export declare const getAdminReviewWithdrawalMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminReviewWithdrawal>>, TError, {
        id: number;
        data: BodyType<WalletReview>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminReviewWithdrawal>>, TError, {
    id: number;
    data: BodyType<WalletReview>;
}, TContext>;
export type AdminReviewWithdrawalMutationResult = NonNullable<Awaited<ReturnType<typeof adminReviewWithdrawal>>>;
export type AdminReviewWithdrawalMutationBody = BodyType<WalletReview>;
export type AdminReviewWithdrawalMutationError = ErrorType<unknown>;
/**
* @summary Admin — approve or reject a withdrawal request
*/
export declare const useAdminReviewWithdrawal: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminReviewWithdrawal>>, TError, {
        id: number;
        data: BodyType<WalletReview>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminReviewWithdrawal>>, TError, {
    id: number;
    data: BodyType<WalletReview>;
}, TContext>;
export declare const getAdminGetCommissionUrl: () => string;
/**
 * @summary Admin — commission earned (today, this month, total)
 */
export declare const adminGetCommission: (options?: RequestInit) => Promise<CommissionStats>;
export declare const getAdminGetCommissionQueryKey: () => readonly ["/api/admin/commission"];
export declare const getAdminGetCommissionQueryOptions: <TData = Awaited<ReturnType<typeof adminGetCommission>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminGetCommission>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminGetCommission>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminGetCommissionQueryResult = NonNullable<Awaited<ReturnType<typeof adminGetCommission>>>;
export type AdminGetCommissionQueryError = ErrorType<unknown>;
/**
 * @summary Admin — commission earned (today, this month, total)
 */
export declare function useAdminGetCommission<TData = Awaited<ReturnType<typeof adminGetCommission>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminGetCommission>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminGetEscrowUrl: () => string;
/**
 * @summary Admin — funds currently held in escrow and admin wallet balance
 */
export declare const adminGetEscrow: (options?: RequestInit) => Promise<EscrowStats>;
export declare const getAdminGetEscrowQueryKey: () => readonly ["/api/admin/escrow"];
export declare const getAdminGetEscrowQueryOptions: <TData = Awaited<ReturnType<typeof adminGetEscrow>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminGetEscrow>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminGetEscrow>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminGetEscrowQueryResult = NonNullable<Awaited<ReturnType<typeof adminGetEscrow>>>;
export type AdminGetEscrowQueryError = ErrorType<unknown>;
/**
 * @summary Admin — funds currently held in escrow and admin wallet balance
 */
export declare function useAdminGetEscrow<TData = Awaited<ReturnType<typeof adminGetEscrow>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminGetEscrow>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminListProofsUrl: () => string;
/**
 * @summary Admin — list order proof submissions for review
 */
export declare const adminListProofs: (options?: RequestInit) => Promise<AdminOrderProof[]>;
export declare const getAdminListProofsQueryKey: () => readonly ["/api/admin/proofs"];
export declare const getAdminListProofsQueryOptions: <TData = Awaited<ReturnType<typeof adminListProofs>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListProofs>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof adminListProofs>>, TError, TData> & {
    queryKey: QueryKey;
};
export type AdminListProofsQueryResult = NonNullable<Awaited<ReturnType<typeof adminListProofs>>>;
export type AdminListProofsQueryError = ErrorType<unknown>;
/**
 * @summary Admin — list order proof submissions for review
 */
export declare function useAdminListProofs<TData = Awaited<ReturnType<typeof adminListProofs>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof adminListProofs>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAdminReviewProofUrl: (id: number) => string;
/**
 * @summary Admin — approve or reject an order proof
 */
export declare const adminReviewProof: (id: number, proofReviewInput: ProofReviewInput, options?: RequestInit) => Promise<AdminOrderProof>;
export declare const getAdminReviewProofMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminReviewProof>>, TError, {
        id: number;
        data: BodyType<ProofReviewInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof adminReviewProof>>, TError, {
    id: number;
    data: BodyType<ProofReviewInput>;
}, TContext>;
export type AdminReviewProofMutationResult = NonNullable<Awaited<ReturnType<typeof adminReviewProof>>>;
export type AdminReviewProofMutationBody = BodyType<ProofReviewInput>;
export type AdminReviewProofMutationError = ErrorType<unknown>;
/**
* @summary Admin — approve or reject an order proof
*/
export declare const useAdminReviewProof: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof adminReviewProof>>, TError, {
        id: number;
        data: BodyType<ProofReviewInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof adminReviewProof>>, TError, {
    id: number;
    data: BodyType<ProofReviewInput>;
}, TContext>;
export declare const getRegisterModelUrl: () => string;
/**
 * @summary Register a model account (creates account + pending profile application)
 */
export declare const registerModel: (registerModelAccountInput: RegisterModelAccountInput, options?: RequestInit) => Promise<AuthResponse>;
export declare const getRegisterModelMutationOptions: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof registerModel>>, TError, {
        data: BodyType<RegisterModelAccountInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof registerModel>>, TError, {
    data: BodyType<RegisterModelAccountInput>;
}, TContext>;
export type RegisterModelMutationResult = NonNullable<Awaited<ReturnType<typeof registerModel>>>;
export type RegisterModelMutationBody = BodyType<RegisterModelAccountInput>;
export type RegisterModelMutationError = ErrorType<void>;
/**
* @summary Register a model account (creates account + pending profile application)
*/
export declare const useRegisterModel: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof registerModel>>, TError, {
        data: BodyType<RegisterModelAccountInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof registerModel>>, TError, {
    data: BodyType<RegisterModelAccountInput>;
}, TContext>;
export declare const getForgotPasswordUrl: () => string;
/**
 * @summary Request a password reset email
 */
export declare const forgotPassword: (forgotPasswordInput: ForgotPasswordInput, options?: RequestInit) => Promise<void>;
export declare const getForgotPasswordMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof forgotPassword>>, TError, {
        data: BodyType<ForgotPasswordInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof forgotPassword>>, TError, {
    data: BodyType<ForgotPasswordInput>;
}, TContext>;
export type ForgotPasswordMutationResult = NonNullable<Awaited<ReturnType<typeof forgotPassword>>>;
export type ForgotPasswordMutationBody = BodyType<ForgotPasswordInput>;
export type ForgotPasswordMutationError = ErrorType<unknown>;
/**
* @summary Request a password reset email
*/
export declare const useForgotPassword: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof forgotPassword>>, TError, {
        data: BodyType<ForgotPasswordInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof forgotPassword>>, TError, {
    data: BodyType<ForgotPasswordInput>;
}, TContext>;
export declare const getResetPasswordUrl: () => string;
/**
 * @summary Reset password using a token from email
 */
export declare const resetPassword: (resetPasswordInput: ResetPasswordInput, options?: RequestInit) => Promise<void>;
export declare const getResetPasswordMutationOptions: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof resetPassword>>, TError, {
        data: BodyType<ResetPasswordInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof resetPassword>>, TError, {
    data: BodyType<ResetPasswordInput>;
}, TContext>;
export type ResetPasswordMutationResult = NonNullable<Awaited<ReturnType<typeof resetPassword>>>;
export type ResetPasswordMutationBody = BodyType<ResetPasswordInput>;
export type ResetPasswordMutationError = ErrorType<void>;
/**
* @summary Reset password using a token from email
*/
export declare const useResetPassword: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof resetPassword>>, TError, {
        data: BodyType<ResetPasswordInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof resetPassword>>, TError, {
    data: BodyType<ResetPasswordInput>;
}, TContext>;
export declare const getListFavoritesUrl: () => string;
/**
 * @summary List the current user's favorited model profiles
 */
export declare const listFavorites: (options?: RequestInit) => Promise<Profile[]>;
export declare const getListFavoritesQueryKey: () => readonly ["/api/favorites"];
export declare const getListFavoritesQueryOptions: <TData = Awaited<ReturnType<typeof listFavorites>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listFavorites>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listFavorites>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListFavoritesQueryResult = NonNullable<Awaited<ReturnType<typeof listFavorites>>>;
export type ListFavoritesQueryError = ErrorType<unknown>;
/**
 * @summary List the current user's favorited model profiles
 */
export declare function useListFavorites<TData = Awaited<ReturnType<typeof listFavorites>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listFavorites>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAddFavoriteUrl: () => string;
/**
 * @summary Add a model profile to favorites
 */
export declare const addFavorite: (favoriteInput: FavoriteInput, options?: RequestInit) => Promise<void>;
export declare const getAddFavoriteMutationOptions: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof addFavorite>>, TError, {
        data: BodyType<FavoriteInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof addFavorite>>, TError, {
    data: BodyType<FavoriteInput>;
}, TContext>;
export type AddFavoriteMutationResult = NonNullable<Awaited<ReturnType<typeof addFavorite>>>;
export type AddFavoriteMutationBody = BodyType<FavoriteInput>;
export type AddFavoriteMutationError = ErrorType<void>;
/**
* @summary Add a model profile to favorites
*/
export declare const useAddFavorite: <TError = ErrorType<void>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof addFavorite>>, TError, {
        data: BodyType<FavoriteInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof addFavorite>>, TError, {
    data: BodyType<FavoriteInput>;
}, TContext>;
export declare const getRemoveFavoriteUrl: (profileId: number) => string;
/**
 * @summary Remove a model profile from favorites
 */
export declare const removeFavorite: (profileId: number, options?: RequestInit) => Promise<void>;
export declare const getRemoveFavoriteMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof removeFavorite>>, TError, {
        profileId: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof removeFavorite>>, TError, {
    profileId: number;
}, TContext>;
export type RemoveFavoriteMutationResult = NonNullable<Awaited<ReturnType<typeof removeFavorite>>>;
export type RemoveFavoriteMutationError = ErrorType<unknown>;
/**
* @summary Remove a model profile from favorites
*/
export declare const useRemoveFavorite: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof removeFavorite>>, TError, {
        profileId: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof removeFavorite>>, TError, {
    profileId: number;
}, TContext>;
export declare const getGetMyProfileUrl: () => string;
/**
 * @summary Get the current model's own profile
 */
export declare const getMyProfile: (options?: RequestInit) => Promise<Profile>;
export declare const getGetMyProfileQueryKey: () => readonly ["/api/me/profile"];
export declare const getGetMyProfileQueryOptions: <TData = Awaited<ReturnType<typeof getMyProfile>>, TError = ErrorType<void>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getMyProfile>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getMyProfile>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetMyProfileQueryResult = NonNullable<Awaited<ReturnType<typeof getMyProfile>>>;
export type GetMyProfileQueryError = ErrorType<void>;
/**
 * @summary Get the current model's own profile
 */
export declare function useGetMyProfile<TData = Awaited<ReturnType<typeof getMyProfile>>, TError = ErrorType<void>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getMyProfile>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getUpdateMyProfileUrl: () => string;
/**
 * @summary Update the current model's profile and pricing
 */
export declare const updateMyProfile: (modelProfileUpdate: ModelProfileUpdate, options?: RequestInit) => Promise<Profile>;
export declare const getUpdateMyProfileMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateMyProfile>>, TError, {
        data: BodyType<ModelProfileUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof updateMyProfile>>, TError, {
    data: BodyType<ModelProfileUpdate>;
}, TContext>;
export type UpdateMyProfileMutationResult = NonNullable<Awaited<ReturnType<typeof updateMyProfile>>>;
export type UpdateMyProfileMutationBody = BodyType<ModelProfileUpdate>;
export type UpdateMyProfileMutationError = ErrorType<unknown>;
/**
* @summary Update the current model's profile and pricing
*/
export declare const useUpdateMyProfile: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateMyProfile>>, TError, {
        data: BodyType<ModelProfileUpdate>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof updateMyProfile>>, TError, {
    data: BodyType<ModelProfileUpdate>;
}, TContext>;
export declare const getGetMyEarningsUrl: () => string;
/**
 * @summary Get earnings estimated from completed bookings
 */
export declare const getMyEarnings: (options?: RequestInit) => Promise<EarningsSummary>;
export declare const getGetMyEarningsQueryKey: () => readonly ["/api/me/earnings"];
export declare const getGetMyEarningsQueryOptions: <TData = Awaited<ReturnType<typeof getMyEarnings>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getMyEarnings>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof getMyEarnings>>, TError, TData> & {
    queryKey: QueryKey;
};
export type GetMyEarningsQueryResult = NonNullable<Awaited<ReturnType<typeof getMyEarnings>>>;
export type GetMyEarningsQueryError = ErrorType<unknown>;
/**
 * @summary Get earnings estimated from completed bookings
 */
export declare function useGetMyEarnings<TData = Awaited<ReturnType<typeof getMyEarnings>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof getMyEarnings>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListMyOrdersUrl: () => string;
/**
 * @summary List incoming orders for the current model's profile
 */
export declare const listMyOrders: (options?: RequestInit) => Promise<Booking[]>;
export declare const getListMyOrdersQueryKey: () => readonly ["/api/me/orders"];
export declare const getListMyOrdersQueryOptions: <TData = Awaited<ReturnType<typeof listMyOrders>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyOrders>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listMyOrders>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListMyOrdersQueryResult = NonNullable<Awaited<ReturnType<typeof listMyOrders>>>;
export type ListMyOrdersQueryError = ErrorType<unknown>;
/**
 * @summary List incoming orders for the current model's profile
 */
export declare function useListMyOrders<TData = Awaited<ReturnType<typeof listMyOrders>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyOrders>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getListMyPhotosUrl: () => string;
/**
 * @summary List the current model's photo gallery
 */
export declare const listMyPhotos: (options?: RequestInit) => Promise<ProfilePhoto[]>;
export declare const getListMyPhotosQueryKey: () => readonly ["/api/me/photos"];
export declare const getListMyPhotosQueryOptions: <TData = Awaited<ReturnType<typeof listMyPhotos>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyPhotos>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}) => UseQueryOptions<Awaited<ReturnType<typeof listMyPhotos>>, TError, TData> & {
    queryKey: QueryKey;
};
export type ListMyPhotosQueryResult = NonNullable<Awaited<ReturnType<typeof listMyPhotos>>>;
export type ListMyPhotosQueryError = ErrorType<unknown>;
/**
 * @summary List the current model's photo gallery
 */
export declare function useListMyPhotos<TData = Awaited<ReturnType<typeof listMyPhotos>>, TError = ErrorType<unknown>>(options?: {
    query?: UseQueryOptions<Awaited<ReturnType<typeof listMyPhotos>>, TError, TData>;
    request?: SecondParameter<typeof customFetch>;
}): UseQueryResult<TData, TError> & {
    queryKey: QueryKey;
};
export declare const getAddMyPhotoUrl: () => string;
/**
 * @summary Add a photo to the gallery
 */
export declare const addMyPhoto: (addPhotoInput: AddPhotoInput, options?: RequestInit) => Promise<ProfilePhoto>;
export declare const getAddMyPhotoMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof addMyPhoto>>, TError, {
        data: BodyType<AddPhotoInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof addMyPhoto>>, TError, {
    data: BodyType<AddPhotoInput>;
}, TContext>;
export type AddMyPhotoMutationResult = NonNullable<Awaited<ReturnType<typeof addMyPhoto>>>;
export type AddMyPhotoMutationBody = BodyType<AddPhotoInput>;
export type AddMyPhotoMutationError = ErrorType<unknown>;
/**
* @summary Add a photo to the gallery
*/
export declare const useAddMyPhoto: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof addMyPhoto>>, TError, {
        data: BodyType<AddPhotoInput>;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof addMyPhoto>>, TError, {
    data: BodyType<AddPhotoInput>;
}, TContext>;
export declare const getDeleteMyPhotoUrl: (id: number) => string;
/**
 * @summary Delete a photo from the gallery
 */
export declare const deleteMyPhoto: (id: number, options?: RequestInit) => Promise<void>;
export declare const getDeleteMyPhotoMutationOptions: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof deleteMyPhoto>>, TError, {
        id: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationOptions<Awaited<ReturnType<typeof deleteMyPhoto>>, TError, {
    id: number;
}, TContext>;
export type DeleteMyPhotoMutationResult = NonNullable<Awaited<ReturnType<typeof deleteMyPhoto>>>;
export type DeleteMyPhotoMutationError = ErrorType<unknown>;
/**
* @summary Delete a photo from the gallery
*/
export declare const useDeleteMyPhoto: <TError = ErrorType<unknown>, TContext = unknown>(options?: {
    mutation?: UseMutationOptions<Awaited<ReturnType<typeof deleteMyPhoto>>, TError, {
        id: number;
    }, TContext>;
    request?: SecondParameter<typeof customFetch>;
}) => UseMutationResult<Awaited<ReturnType<typeof deleteMyPhoto>>, TError, {
    id: number;
}, TContext>;
export {};
//# sourceMappingURL=api.d.ts.map