/**
 * Generated by orval v8.9.1 🍺
 * Do not edit manually.
 * Api
 * Model Directory & Booking Platform API
 * OpenAPI spec version: 0.1.0
 */
import {
  useMutation,
  useQuery
} from '@tanstack/react-query';
import type {
  MutationFunction,
  QueryFunction,
  QueryKey,
  UseMutationOptions,
  UseMutationResult,
  UseQueryOptions,
  UseQueryResult
} from '@tanstack/react-query';

import type {
  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 const getRequestUploadUrlUrl = () => {




  return `/api/storage/uploads/request-url`
}

/**
 * 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 const requestUploadUrl = async (uploadUrlRequest: UploadUrlRequest, options?: RequestInit): Promise<UploadUrlResponse> => {

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




export 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> => {

const mutationKey = ['requestUploadUrl'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof requestUploadUrl>>, {data: BodyType<UploadUrlRequest>}> = (props) => {
          const {data} = props ?? {};

          return  requestUploadUrl(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getRequestUploadUrlMutationOptions(options));
    }

export const getGetPublicObjectUrl = (filePath: string,) => {




  return `/api/storage/public-objects/${filePath}`
}

/**
 * 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 const getPublicObject = async (filePath: string, options?: RequestInit): Promise<Blob> => {

  return customFetch<Blob>(getGetPublicObjectUrl(filePath),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetPublicObjectQueryKey = (filePath: string,) => {
    return [
    `/api/storage/public-objects/${filePath}`
    ] as const;
    }


export 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>}
) => {

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

  const queryKey =  queryOptions?.queryKey ?? getGetPublicObjectQueryKey(filePath);



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





   return  { queryKey, queryFn, enabled: !!(filePath), ...queryOptions} as 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 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 } {

  const queryOptions = getGetPublicObjectQueryOptions(filePath,options)

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

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







export const getGetStorageObjectUrl = (objectPath: string,) => {




  return `/api/storage/objects/${objectPath}`
}

/**
 * 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 const getStorageObject = async (objectPath: string, options?: RequestInit): Promise<Blob> => {

  return customFetch<Blob>(getGetStorageObjectUrl(objectPath),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetStorageObjectQueryKey = (objectPath: string,) => {
    return [
    `/api/storage/objects/${objectPath}`
    ] as const;
    }


export 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>}
) => {

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

  const queryKey =  queryOptions?.queryKey ?? getGetStorageObjectQueryKey(objectPath);



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





   return  { queryKey, queryFn, enabled: !!(objectPath), ...queryOptions} as 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 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 } {

  const queryOptions = getGetStorageObjectQueryOptions(objectPath,options)

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

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







export const getHealthCheckUrl = () => {




  return `/api/healthz`
}

/**
 * @summary Health check
 */
export const healthCheck = async ( options?: RequestInit): Promise<HealthStatus> => {

  return customFetch<HealthStatus>(getHealthCheckUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





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

export type HealthCheckQueryResult = NonNullable<Awaited<ReturnType<typeof healthCheck>>>
export type HealthCheckQueryError = ErrorType<unknown>


/**
 * @summary Health check
 */

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

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

  const queryOptions = getHealthCheckQueryOptions(options)

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

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







export const getRegisterUrl = () => {




  return `/api/auth/register`
}

/**
 * @summary Register a new user
 */
export const register = async (registerInput: RegisterInput, options?: RequestInit): Promise<AuthResponse> => {

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




export 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> => {

const mutationKey = ['register'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof register>>, {data: BodyType<RegisterInput>}> = (props) => {
          const {data} = props ?? {};

          return  register(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type RegisterMutationResult = NonNullable<Awaited<ReturnType<typeof register>>>
    export type RegisterMutationBody = BodyType<RegisterInput>
    export type RegisterMutationError = ErrorType<void>

    /**
 * @summary Register a new user
 */
export 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
      > => {
      return useMutation(getRegisterMutationOptions(options));
    }

export const getLoginUrl = () => {




  return `/api/auth/login`
}

/**
 * @summary Log in
 */
export const login = async (loginInput: LoginInput, options?: RequestInit): Promise<AuthResponse> => {

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




export 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> => {

const mutationKey = ['login'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof login>>, {data: BodyType<LoginInput>}> = (props) => {
          const {data} = props ?? {};

          return  login(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type LoginMutationResult = NonNullable<Awaited<ReturnType<typeof login>>>
    export type LoginMutationBody = BodyType<LoginInput>
    export type LoginMutationError = ErrorType<void>

    /**
 * @summary Log in
 */
export 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
      > => {
      return useMutation(getLoginMutationOptions(options));
    }

export const getLogoutUrl = () => {




  return `/api/auth/logout`
}

/**
 * @summary Log out
 */
export const logout = async ( options?: RequestInit): Promise<void> => {

  return customFetch<void>(getLogoutUrl(),
  {
    ...options,
    method: 'POST'


  }
);}




export 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> => {

const mutationKey = ['logout'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof logout>>, void> = () => {


          return  logout(requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type LogoutMutationResult = NonNullable<Awaited<ReturnType<typeof logout>>>

    export type LogoutMutationError = ErrorType<unknown>

    /**
 * @summary Log out
 */
export 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
      > => {
      return useMutation(getLogoutMutationOptions(options));
    }

export const getGetMeUrl = () => {




  return `/api/auth/me`
}

/**
 * @summary Get current user
 */
export const getMe = async ( options?: RequestInit): Promise<User> => {

  return customFetch<User>(getGetMeUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetMeQueryKey = () => {
    return [
    `/api/auth/me`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getGetMeQueryOptions(options)

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

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







export const getUpdateMeUrl = () => {




  return `/api/auth/me/update`
}

/**
 * @summary Update current user profile
 */
export const updateMe = async (userUpdate: UserUpdate, options?: RequestInit): Promise<User> => {

  return customFetch<User>(getUpdateMeUrl(),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      userUpdate,)
  }
);}




export 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> => {

const mutationKey = ['updateMe'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof updateMe>>, {data: BodyType<UserUpdate>}> = (props) => {
          const {data} = props ?? {};

          return  updateMe(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateMeMutationResult = NonNullable<Awaited<ReturnType<typeof updateMe>>>
    export type UpdateMeMutationBody = BodyType<UserUpdate>
    export type UpdateMeMutationError = ErrorType<unknown>

    /**
 * @summary Update current user profile
 */
export 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
      > => {
      return useMutation(getUpdateMeMutationOptions(options));
    }

export const getGetDashboardSummaryUrl = () => {




  return `/api/dashboard/summary`
}

/**
 * @summary Get dashboard summary for current user
 */
export const getDashboardSummary = async ( options?: RequestInit): Promise<DashboardSummary> => {

  return customFetch<DashboardSummary>(getGetDashboardSummaryUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getGetDashboardSummaryQueryOptions(options)

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

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







export const getGetFeaturedProfilesUrl = () => {




  return `/api/dashboard/featured-profiles`
}

/**
 * @summary Get featured model profiles
 */
export const getFeaturedProfiles = async ( options?: RequestInit): Promise<Profile[]> => {

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


  }
);}





export const getGetFeaturedProfilesQueryKey = () => {
    return [
    `/api/dashboard/featured-profiles`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getGetFeaturedProfilesQueryOptions(options)

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

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







export const getGetFeaturedLocationsUrl = () => {




  return `/api/dashboard/featured-locations`
}

/**
 * @summary Get featured locations
 */
export const getFeaturedLocations = async ( options?: RequestInit): Promise<Location[]> => {

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


  }
);}





export const getGetFeaturedLocationsQueryKey = () => {
    return [
    `/api/dashboard/featured-locations`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getGetFeaturedLocationsQueryOptions(options)

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

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







export const getGetRecentActivityUrl = () => {




  return `/api/dashboard/recent-activity`
}

/**
 * @summary Get recent booking activity for current user
 */
export const getRecentActivity = async ( options?: RequestInit): Promise<Booking[]> => {

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


  }
);}





export const getGetRecentActivityQueryKey = () => {
    return [
    `/api/dashboard/recent-activity`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getGetRecentActivityQueryOptions(options)

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

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







export const getListProfilesUrl = (params?: ListProfilesParams,) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {

    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : value.toString())
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0 ? `/api/profiles?${stringifiedParams}` : `/api/profiles`
}

/**
 * @summary List all model profiles
 */
export const listProfiles = async (params?: ListProfilesParams, options?: RequestInit): Promise<Profile[]> => {

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


  }
);}





export const getListProfilesQueryKey = (params?: ListProfilesParams,) => {
    return [
    `/api/profiles`, ...(params ? [params] : [])
    ] as const;
    }


export 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>}
) => {

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListProfilesQueryOptions(params,options)

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

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







export const getCreateModelApplicationUrl = () => {




  return `/api/profiles`
}

/**
 * @summary Submit a model registration application (pending admin approval)
 */
export const createModelApplication = async (registerModelInput: RegisterModelInput, options?: RequestInit): Promise<Profile> => {

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




export 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> => {

const mutationKey = ['createModelApplication'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof createModelApplication>>, {data: BodyType<RegisterModelInput>}> = (props) => {
          const {data} = props ?? {};

          return  createModelApplication(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getCreateModelApplicationMutationOptions(options));
    }

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




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

/**
 * @summary Get a profile by ID
 */
export const getProfile = async (id: number, options?: RequestInit): Promise<Profile> => {

  return customFetch<Profile>(getGetProfileUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





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


export 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>}
) => {

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

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



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





   return  { queryKey, queryFn, enabled: !!(id), ...queryOptions} as 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 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 } {

  const queryOptions = getGetProfileQueryOptions(id,options)

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

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







export const getListLocationsUrl = (params?: ListLocationsParams,) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {

    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : value.toString())
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0 ? `/api/locations?${stringifiedParams}` : `/api/locations`
}

/**
 * @summary List all locations
 */
export const listLocations = async (params?: ListLocationsParams, options?: RequestInit): Promise<Location[]> => {

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


  }
);}





export const getListLocationsQueryKey = (params?: ListLocationsParams,) => {
    return [
    `/api/locations`, ...(params ? [params] : [])
    ] as const;
    }


export 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>}
) => {

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListLocationsQueryOptions(params,options)

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

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







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




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

/**
 * @summary Get a location by ID
 */
export const getLocation = async (id: number, options?: RequestInit): Promise<Location> => {

  return customFetch<Location>(getGetLocationUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





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


export 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>}
) => {

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

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



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





   return  { queryKey, queryFn, enabled: !!(id), ...queryOptions} as 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 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 } {

  const queryOptions = getGetLocationQueryOptions(id,options)

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

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







export const getListServicesUrl = () => {




  return `/api/services`
}

/**
 * @summary List bookable services
 */
export const listServices = async ( options?: RequestInit): Promise<Service[]> => {

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


  }
);}





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


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListServicesQueryOptions(options)

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

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







export const getListMyBookingsUrl = () => {




  return `/api/bookings`
}

/**
 * @summary List current user's bookings
 */
export const listMyBookings = async ( options?: RequestInit): Promise<Booking[]> => {

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


  }
);}





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


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListMyBookingsQueryOptions(options)

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

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







export const getCreateBookingUrl = () => {




  return `/api/bookings`
}

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

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




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

const mutationKey = ['createBooking'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof createBooking>>, {data: BodyType<BookingInput>}> = (props) => {
          const {data} = props ?? {};

          return  createBooking(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

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

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

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




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

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

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


  }
);}





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


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

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

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



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





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

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


/**
 * @summary Get a booking by ID
 */

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

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

  const queryOptions = getGetBookingQueryOptions(id,options)

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

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







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




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

/**
 * @summary Cancel a booking
 */
export const cancelBooking = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




export 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> => {

const mutationKey = ['cancelBooking'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof cancelBooking>>, {id: number}> = (props) => {
          const {id} = props ?? {};

          return  cancelBooking(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CancelBookingMutationResult = NonNullable<Awaited<ReturnType<typeof cancelBooking>>>

    export type CancelBookingMutationError = ErrorType<unknown>

    /**
 * @summary Cancel a booking
 */
export 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
      > => {
      return useMutation(getCancelBookingMutationOptions(options));
    }

export const getGetMyMembershipUrl = () => {




  return `/api/memberships/my`
}

/**
 * @summary Get current user's membership
 */
export const getMyMembership = async ( options?: RequestInit): Promise<Membership> => {

  return customFetch<Membership>(getGetMyMembershipUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetMyMembershipQueryKey = () => {
    return [
    `/api/memberships/my`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getGetMyMembershipQueryOptions(options)

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

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







export const getListMembershipTiersUrl = () => {




  return `/api/memberships/tiers`
}

/**
 * @summary List available membership plans
 */
export const listMembershipTiers = async ( options?: RequestInit): Promise<MembershipPlan[]> => {

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


  }
);}





export const getListMembershipTiersQueryKey = () => {
    return [
    `/api/memberships/tiers`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListMembershipTiersQueryOptions(options)

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

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







export const getListPaymentMethodsUrl = () => {




  return `/api/memberships/payment-methods`
}

/**
 * @summary List active payment methods
 */
export const listPaymentMethods = async ( options?: RequestInit): Promise<PaymentMethod[]> => {

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


  }
);}





export const getListPaymentMethodsQueryKey = () => {
    return [
    `/api/memberships/payment-methods`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListPaymentMethodsQueryOptions(options)

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

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







export const getSubscribeMembershipUrl = () => {




  return `/api/memberships/subscribe`
}

/**
 * @summary Submit a membership payment for verification
 */
export const subscribeMembership = async (subscribeInput: SubscribeInput, options?: RequestInit): Promise<MembershipPayment> => {

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




export 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> => {

const mutationKey = ['subscribeMembership'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof subscribeMembership>>, {data: BodyType<SubscribeInput>}> = (props) => {
          const {data} = props ?? {};

          return  subscribeMembership(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getSubscribeMembershipMutationOptions(options));
    }

export const getListMyMembershipPaymentsUrl = () => {




  return `/api/memberships/my-payments`
}

/**
 * @summary List current user's membership payment submissions
 */
export const listMyMembershipPayments = async ( options?: RequestInit): Promise<MembershipPayment[]> => {

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


  }
);}





export const getListMyMembershipPaymentsQueryKey = () => {
    return [
    `/api/memberships/my-payments`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListMyMembershipPaymentsQueryOptions(options)

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

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







export const getListNetworkMembersUrl = () => {




  return `/api/network/members`
}

/**
 * @summary List network members (other users in the platform)
 */
export const listNetworkMembers = async ( options?: RequestInit): Promise<NetworkMember[]> => {

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


  }
);}





export const getListNetworkMembersQueryKey = () => {
    return [
    `/api/network/members`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListNetworkMembersQueryOptions(options)

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

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







export const getListAssetsUrl = () => {




  return `/api/assets`
}

/**
 * @summary List platform assets (resources, links, tools)
 */
export const listAssets = async ( options?: RequestInit): Promise<Asset[]> => {

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


  }
);}





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


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListAssetsQueryOptions(options)

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

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







export const getAdminListProfilesUrl = () => {




  return `/api/admin/profiles`
}

/**
 * @summary Admin — list all profiles
 */
export const adminListProfiles = async ( options?: RequestInit): Promise<Profile[]> => {

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


  }
);}





export const getAdminListProfilesQueryKey = () => {
    return [
    `/api/admin/profiles`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListProfilesQueryOptions(options)

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

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







export const getAdminCreateProfileUrl = () => {




  return `/api/admin/profiles`
}

/**
 * @summary Admin — create a profile
 */
export const adminCreateProfile = async (profileInput: ProfileInput, options?: RequestInit): Promise<Profile> => {

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




export 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> => {

const mutationKey = ['adminCreateProfile'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminCreateProfile>>, {data: BodyType<ProfileInput>}> = (props) => {
          const {data} = props ?? {};

          return  adminCreateProfile(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type AdminCreateProfileMutationResult = NonNullable<Awaited<ReturnType<typeof adminCreateProfile>>>
    export type AdminCreateProfileMutationBody = BodyType<ProfileInput>
    export type AdminCreateProfileMutationError = ErrorType<unknown>

    /**
 * @summary Admin — create a profile
 */
export 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
      > => {
      return useMutation(getAdminCreateProfileMutationOptions(options));
    }

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




  return `/api/admin/profiles/${id}`
}

/**
 * @summary Admin — update a profile
 */
export const adminUpdateProfile = async (id: number,
    profileUpdate: ProfileUpdate, options?: RequestInit): Promise<Profile> => {

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




export 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> => {

const mutationKey = ['adminUpdateProfile'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminUpdateProfile>>, {id: number;data: BodyType<ProfileUpdate>}> = (props) => {
          const {id,data} = props ?? {};

          return  adminUpdateProfile(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type AdminUpdateProfileMutationResult = NonNullable<Awaited<ReturnType<typeof adminUpdateProfile>>>
    export type AdminUpdateProfileMutationBody = BodyType<ProfileUpdate>
    export type AdminUpdateProfileMutationError = ErrorType<unknown>

    /**
 * @summary Admin — update a profile
 */
export 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
      > => {
      return useMutation(getAdminUpdateProfileMutationOptions(options));
    }

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




  return `/api/admin/profiles/${id}`
}

/**
 * @summary Admin — delete a profile
 */
export const adminDeleteProfile = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




export 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> => {

const mutationKey = ['adminDeleteProfile'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminDeleteProfile>>, {id: number}> = (props) => {
          const {id} = props ?? {};

          return  adminDeleteProfile(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type AdminDeleteProfileMutationResult = NonNullable<Awaited<ReturnType<typeof adminDeleteProfile>>>

    export type AdminDeleteProfileMutationError = ErrorType<unknown>

    /**
 * @summary Admin — delete a profile
 */
export 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
      > => {
      return useMutation(getAdminDeleteProfileMutationOptions(options));
    }

export const getAdminListLocationsUrl = () => {




  return `/api/admin/locations`
}

/**
 * @summary Admin — list all locations
 */
export const adminListLocations = async ( options?: RequestInit): Promise<Location[]> => {

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


  }
);}





export const getAdminListLocationsQueryKey = () => {
    return [
    `/api/admin/locations`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListLocationsQueryOptions(options)

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

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







export const getAdminCreateLocationUrl = () => {




  return `/api/admin/locations`
}

/**
 * @summary Admin — create a location
 */
export const adminCreateLocation = async (locationInput: LocationInput, options?: RequestInit): Promise<Location> => {

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




export 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> => {

const mutationKey = ['adminCreateLocation'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminCreateLocation>>, {data: BodyType<LocationInput>}> = (props) => {
          const {data} = props ?? {};

          return  adminCreateLocation(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type AdminCreateLocationMutationResult = NonNullable<Awaited<ReturnType<typeof adminCreateLocation>>>
    export type AdminCreateLocationMutationBody = BodyType<LocationInput>
    export type AdminCreateLocationMutationError = ErrorType<unknown>

    /**
 * @summary Admin — create a location
 */
export 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
      > => {
      return useMutation(getAdminCreateLocationMutationOptions(options));
    }

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




  return `/api/admin/locations/${id}`
}

/**
 * @summary Admin — update a location
 */
export const adminUpdateLocation = async (id: number,
    locationUpdate: LocationUpdate, options?: RequestInit): Promise<Location> => {

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




export 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> => {

const mutationKey = ['adminUpdateLocation'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminUpdateLocation>>, {id: number;data: BodyType<LocationUpdate>}> = (props) => {
          const {id,data} = props ?? {};

          return  adminUpdateLocation(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type AdminUpdateLocationMutationResult = NonNullable<Awaited<ReturnType<typeof adminUpdateLocation>>>
    export type AdminUpdateLocationMutationBody = BodyType<LocationUpdate>
    export type AdminUpdateLocationMutationError = ErrorType<unknown>

    /**
 * @summary Admin — update a location
 */
export 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
      > => {
      return useMutation(getAdminUpdateLocationMutationOptions(options));
    }

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




  return `/api/admin/locations/${id}`
}

/**
 * @summary Admin — delete a location
 */
export const adminDeleteLocation = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




export 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> => {

const mutationKey = ['adminDeleteLocation'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminDeleteLocation>>, {id: number}> = (props) => {
          const {id} = props ?? {};

          return  adminDeleteLocation(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type AdminDeleteLocationMutationResult = NonNullable<Awaited<ReturnType<typeof adminDeleteLocation>>>

    export type AdminDeleteLocationMutationError = ErrorType<unknown>

    /**
 * @summary Admin — delete a location
 */
export 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
      > => {
      return useMutation(getAdminDeleteLocationMutationOptions(options));
    }

export const getAdminListMembershipsUrl = () => {




  return `/api/admin/memberships`
}

/**
 * @summary Admin — list all user memberships
 */
export const adminListMemberships = async ( options?: RequestInit): Promise<Membership[]> => {

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


  }
);}





export const getAdminListMembershipsQueryKey = () => {
    return [
    `/api/admin/memberships`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListMembershipsQueryOptions(options)

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

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







export const getAdminUpdateMembershipUrl = (userId: number,) => {




  return `/api/admin/memberships/${userId}`
}

/**
 * @summary Admin — update a user's membership tier
 */
export const adminUpdateMembership = async (userId: number,
    membershipUpdate: MembershipUpdate, options?: RequestInit): Promise<Membership> => {

  return customFetch<Membership>(getAdminUpdateMembershipUrl(userId),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      membershipUpdate,)
  }
);}




export 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> => {

const mutationKey = ['adminUpdateMembership'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminUpdateMembership>>, {userId: number;data: BodyType<MembershipUpdate>}> = (props) => {
          const {userId,data} = props ?? {};

          return  adminUpdateMembership(userId,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAdminUpdateMembershipMutationOptions(options));
    }

export const getAdminListMembershipPlansUrl = () => {




  return `/api/admin/membership-plans`
}

/**
 * @summary Admin — list all membership plans
 */
export const adminListMembershipPlans = async ( options?: RequestInit): Promise<MembershipPlan[]> => {

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


  }
);}





export const getAdminListMembershipPlansQueryKey = () => {
    return [
    `/api/admin/membership-plans`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListMembershipPlansQueryOptions(options)

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

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







export const getAdminCreateMembershipPlanUrl = () => {




  return `/api/admin/membership-plans`
}

/**
 * @summary Admin — create a membership plan
 */
export const adminCreateMembershipPlan = async (membershipPlanInput: MembershipPlanInput, options?: RequestInit): Promise<MembershipPlan> => {

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




export 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> => {

const mutationKey = ['adminCreateMembershipPlan'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminCreateMembershipPlan>>, {data: BodyType<MembershipPlanInput>}> = (props) => {
          const {data} = props ?? {};

          return  adminCreateMembershipPlan(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAdminCreateMembershipPlanMutationOptions(options));
    }

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




  return `/api/admin/membership-plans/${id}`
}

/**
 * @summary Admin — update a membership plan
 */
export const adminUpdateMembershipPlan = async (id: number,
    membershipPlanUpdate: MembershipPlanUpdate, options?: RequestInit): Promise<MembershipPlan> => {

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




export 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> => {

const mutationKey = ['adminUpdateMembershipPlan'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminUpdateMembershipPlan>>, {id: number;data: BodyType<MembershipPlanUpdate>}> = (props) => {
          const {id,data} = props ?? {};

          return  adminUpdateMembershipPlan(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAdminUpdateMembershipPlanMutationOptions(options));
    }

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




  return `/api/admin/membership-plans/${id}`
}

/**
 * @summary Admin — delete a membership plan
 */
export const adminDeleteMembershipPlan = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




export 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> => {

const mutationKey = ['adminDeleteMembershipPlan'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminDeleteMembershipPlan>>, {id: number}> = (props) => {
          const {id} = props ?? {};

          return  adminDeleteMembershipPlan(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type AdminDeleteMembershipPlanMutationResult = NonNullable<Awaited<ReturnType<typeof adminDeleteMembershipPlan>>>

    export type AdminDeleteMembershipPlanMutationError = ErrorType<unknown>

    /**
 * @summary Admin — delete a membership plan
 */
export 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
      > => {
      return useMutation(getAdminDeleteMembershipPlanMutationOptions(options));
    }

export const getAdminListPaymentMethodsUrl = () => {




  return `/api/admin/payment-methods`
}

/**
 * @summary Admin — list all payment methods
 */
export const adminListPaymentMethods = async ( options?: RequestInit): Promise<PaymentMethod[]> => {

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


  }
);}





export const getAdminListPaymentMethodsQueryKey = () => {
    return [
    `/api/admin/payment-methods`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListPaymentMethodsQueryOptions(options)

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

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







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




  return `/api/admin/payment-methods/${id}`
}

/**
 * @summary Admin — update a payment method
 */
export const adminUpdatePaymentMethod = async (id: number,
    paymentMethodUpdate: PaymentMethodUpdate, options?: RequestInit): Promise<PaymentMethod> => {

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




export 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> => {

const mutationKey = ['adminUpdatePaymentMethod'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminUpdatePaymentMethod>>, {id: number;data: BodyType<PaymentMethodUpdate>}> = (props) => {
          const {id,data} = props ?? {};

          return  adminUpdatePaymentMethod(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAdminUpdatePaymentMethodMutationOptions(options));
    }

export const getAdminListMembershipPaymentsUrl = () => {




  return `/api/admin/membership-payments`
}

/**
 * @summary Admin — list all membership payment submissions
 */
export const adminListMembershipPayments = async ( options?: RequestInit): Promise<MembershipPayment[]> => {

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


  }
);}





export const getAdminListMembershipPaymentsQueryKey = () => {
    return [
    `/api/admin/membership-payments`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListMembershipPaymentsQueryOptions(options)

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

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







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




  return `/api/admin/membership-payments/${id}`
}

/**
 * @summary Admin — approve or reject a membership payment
 */
export const adminReviewMembershipPayment = async (id: number,
    membershipPaymentReview: MembershipPaymentReview, options?: RequestInit): Promise<MembershipPayment> => {

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




export 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> => {

const mutationKey = ['adminReviewMembershipPayment'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminReviewMembershipPayment>>, {id: number;data: BodyType<MembershipPaymentReview>}> = (props) => {
          const {id,data} = props ?? {};

          return  adminReviewMembershipPayment(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAdminReviewMembershipPaymentMutationOptions(options));
    }

export const getAdminListBookingsUrl = () => {




  return `/api/admin/bookings`
}

/**
 * @summary Admin — list all bookings
 */
export const adminListBookings = async ( options?: RequestInit): Promise<Booking[]> => {

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


  }
);}





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


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListBookingsQueryOptions(options)

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

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







export const getAdminListUsersUrl = () => {




  return `/api/admin/users`
}

/**
 * @summary Admin — list all users
 */
export const adminListUsers = async ( options?: RequestInit): Promise<User[]> => {

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


  }
);}





export const getAdminListUsersQueryKey = () => {
    return [
    `/api/admin/users`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListUsersQueryOptions(options)

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

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







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




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

/**
 * @summary Update a booking's status (role-aware transition)
 */
export const updateBookingStatus = async (id: number,
    bookingStatusInput: BookingStatusInput, options?: RequestInit): Promise<Booking> => {

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




export 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> => {

const mutationKey = ['updateBookingStatus'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof updateBookingStatus>>, {id: number;data: BodyType<BookingStatusInput>}> = (props) => {
          const {id,data} = props ?? {};

          return  updateBookingStatus(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

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

    /**
 * @summary Update a booking's status (role-aware transition)
 */
export 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
      > => {
      return useMutation(getUpdateBookingStatusMutationOptions(options));
    }

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




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

/**
 * @summary Model uploads a proof-of-completion photo for a paid order
 */
export const uploadBookingProof = async (id: number,
    proofUploadInput: ProofUploadInput, options?: RequestInit): Promise<Booking> => {

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




export 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> => {

const mutationKey = ['uploadBookingProof'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof uploadBookingProof>>, {id: number;data: BodyType<ProofUploadInput>}> = (props) => {
          const {id,data} = props ?? {};

          return  uploadBookingProof(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getUploadBookingProofMutationOptions(options));
    }

export const getGetWalletUrl = () => {




  return `/api/wallet`
}

/**
 * @summary Get current user's wallet balance and recent transactions
 */
export const getWallet = async ( options?: RequestInit): Promise<Wallet> => {

  return customFetch<Wallet>(getGetWalletUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getGetWalletQueryOptions(options)

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

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







export const getListWalletTransactionsUrl = () => {




  return `/api/wallet/transactions`
}

/**
 * @summary List all of the current user's wallet transactions
 */
export const listWalletTransactions = async ( options?: RequestInit): Promise<WalletTransaction[]> => {

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


  }
);}





export const getListWalletTransactionsQueryKey = () => {
    return [
    `/api/wallet/transactions`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListWalletTransactionsQueryOptions(options)

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

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







export const getListMyDepositsUrl = () => {




  return `/api/wallet/deposits`
}

/**
 * @summary List current user's deposit requests
 */
export const listMyDeposits = async ( options?: RequestInit): Promise<WalletDeposit[]> => {

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


  }
);}





export const getListMyDepositsQueryKey = () => {
    return [
    `/api/wallet/deposits`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListMyDepositsQueryOptions(options)

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

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







export const getCreateDepositUrl = () => {




  return `/api/wallet/deposits`
}

/**
 * @summary Submit a wallet deposit request
 */
export const createDeposit = async (depositInput: DepositInput, options?: RequestInit): Promise<WalletDeposit> => {

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




export 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> => {

const mutationKey = ['createDeposit'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof createDeposit>>, {data: BodyType<DepositInput>}> = (props) => {
          const {data} = props ?? {};

          return  createDeposit(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getCreateDepositMutationOptions(options));
    }

export const getListMyWithdrawalsUrl = () => {




  return `/api/wallet/withdrawals`
}

/**
 * @summary List current user's withdrawal requests
 */
export const listMyWithdrawals = async ( options?: RequestInit): Promise<Withdrawal[]> => {

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


  }
);}





export const getListMyWithdrawalsQueryKey = () => {
    return [
    `/api/wallet/withdrawals`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListMyWithdrawalsQueryOptions(options)

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

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







export const getCreateWithdrawalUrl = () => {




  return `/api/wallet/withdrawals`
}

/**
 * @summary Request a payout (model only)
 */
export const createWithdrawal = async (withdrawalInput: WithdrawalInput, options?: RequestInit): Promise<Withdrawal> => {

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




export 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> => {

const mutationKey = ['createWithdrawal'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof createWithdrawal>>, {data: BodyType<WithdrawalInput>}> = (props) => {
          const {data} = props ?? {};

          return  createWithdrawal(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getCreateWithdrawalMutationOptions(options));
    }

export const getAdminListWalletsUrl = () => {




  return `/api/admin/wallets`
}

/**
 * @summary Admin — list all wallets
 */
export const adminListWallets = async ( options?: RequestInit): Promise<AdminWallet[]> => {

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


  }
);}





export const getAdminListWalletsQueryKey = () => {
    return [
    `/api/admin/wallets`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListWalletsQueryOptions(options)

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

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







export const getAdminCreditWalletUrl = (userId: number,) => {




  return `/api/admin/wallets/${userId}/credit`
}

/**
 * @summary Admin — credit (or debit) a user's wallet
 */
export const adminCreditWallet = async (userId: number,
    walletCreditInput: WalletCreditInput, options?: RequestInit): Promise<AdminWallet> => {

  return customFetch<AdminWallet>(getAdminCreditWalletUrl(userId),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      walletCreditInput,)
  }
);}




export 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> => {

const mutationKey = ['adminCreditWallet'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminCreditWallet>>, {userId: number;data: BodyType<WalletCreditInput>}> = (props) => {
          const {userId,data} = props ?? {};

          return  adminCreditWallet(userId,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAdminCreditWalletMutationOptions(options));
    }

export const getAdminListDepositsUrl = () => {




  return `/api/admin/deposits`
}

/**
 * @summary Admin — list all deposit requests
 */
export const adminListDeposits = async ( options?: RequestInit): Promise<WalletDeposit[]> => {

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


  }
);}





export const getAdminListDepositsQueryKey = () => {
    return [
    `/api/admin/deposits`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListDepositsQueryOptions(options)

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

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







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




  return `/api/admin/deposits/${id}`
}

/**
 * @summary Admin — approve or reject a deposit request
 */
export const adminReviewDeposit = async (id: number,
    walletReview: WalletReview, options?: RequestInit): Promise<WalletDeposit> => {

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




export 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> => {

const mutationKey = ['adminReviewDeposit'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminReviewDeposit>>, {id: number;data: BodyType<WalletReview>}> = (props) => {
          const {id,data} = props ?? {};

          return  adminReviewDeposit(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAdminReviewDepositMutationOptions(options));
    }

export const getAdminListWithdrawalsUrl = () => {




  return `/api/admin/withdrawals`
}

/**
 * @summary Admin — list all withdrawal requests
 */
export const adminListWithdrawals = async ( options?: RequestInit): Promise<Withdrawal[]> => {

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


  }
);}





export const getAdminListWithdrawalsQueryKey = () => {
    return [
    `/api/admin/withdrawals`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListWithdrawalsQueryOptions(options)

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

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







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




  return `/api/admin/withdrawals/${id}`
}

/**
 * @summary Admin — approve or reject a withdrawal request
 */
export const adminReviewWithdrawal = async (id: number,
    walletReview: WalletReview, options?: RequestInit): Promise<Withdrawal> => {

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




export 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> => {

const mutationKey = ['adminReviewWithdrawal'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminReviewWithdrawal>>, {id: number;data: BodyType<WalletReview>}> = (props) => {
          const {id,data} = props ?? {};

          return  adminReviewWithdrawal(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAdminReviewWithdrawalMutationOptions(options));
    }

export const getAdminGetCommissionUrl = () => {




  return `/api/admin/commission`
}

/**
 * @summary Admin — commission earned (today, this month, total)
 */
export const adminGetCommission = async ( options?: RequestInit): Promise<CommissionStats> => {

  return customFetch<CommissionStats>(getAdminGetCommissionUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getAdminGetCommissionQueryKey = () => {
    return [
    `/api/admin/commission`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminGetCommissionQueryOptions(options)

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

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







export const getAdminGetEscrowUrl = () => {




  return `/api/admin/escrow`
}

/**
 * @summary Admin — funds currently held in escrow and admin wallet balance
 */
export const adminGetEscrow = async ( options?: RequestInit): Promise<EscrowStats> => {

  return customFetch<EscrowStats>(getAdminGetEscrowUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getAdminGetEscrowQueryKey = () => {
    return [
    `/api/admin/escrow`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminGetEscrowQueryOptions(options)

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

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







export const getAdminListProofsUrl = () => {




  return `/api/admin/proofs`
}

/**
 * @summary Admin — list order proof submissions for review
 */
export const adminListProofs = async ( options?: RequestInit): Promise<AdminOrderProof[]> => {

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


  }
);}





export const getAdminListProofsQueryKey = () => {
    return [
    `/api/admin/proofs`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getAdminListProofsQueryOptions(options)

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

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







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




  return `/api/admin/proofs/${id}`
}

/**
 * @summary Admin — approve or reject an order proof
 */
export const adminReviewProof = async (id: number,
    proofReviewInput: ProofReviewInput, options?: RequestInit): Promise<AdminOrderProof> => {

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




export 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> => {

const mutationKey = ['adminReviewProof'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof adminReviewProof>>, {id: number;data: BodyType<ProofReviewInput>}> = (props) => {
          const {id,data} = props ?? {};

          return  adminReviewProof(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAdminReviewProofMutationOptions(options));
    }

export const getRegisterModelUrl = () => {




  return `/api/auth/register-model`
}

/**
 * @summary Register a model account (creates account + pending profile application)
 */
export const registerModel = async (registerModelAccountInput: RegisterModelAccountInput, options?: RequestInit): Promise<AuthResponse> => {

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




export 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> => {

const mutationKey = ['registerModel'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof registerModel>>, {data: BodyType<RegisterModelAccountInput>}> = (props) => {
          const {data} = props ?? {};

          return  registerModel(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getRegisterModelMutationOptions(options));
    }

export const getForgotPasswordUrl = () => {




  return `/api/auth/forgot-password`
}

/**
 * @summary Request a password reset email
 */
export const forgotPassword = async (forgotPasswordInput: ForgotPasswordInput, options?: RequestInit): Promise<void> => {

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




export 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> => {

const mutationKey = ['forgotPassword'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof forgotPassword>>, {data: BodyType<ForgotPasswordInput>}> = (props) => {
          const {data} = props ?? {};

          return  forgotPassword(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getForgotPasswordMutationOptions(options));
    }

export const getResetPasswordUrl = () => {




  return `/api/auth/reset-password`
}

/**
 * @summary Reset password using a token from email
 */
export const resetPassword = async (resetPasswordInput: ResetPasswordInput, options?: RequestInit): Promise<void> => {

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




export 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> => {

const mutationKey = ['resetPassword'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof resetPassword>>, {data: BodyType<ResetPasswordInput>}> = (props) => {
          const {data} = props ?? {};

          return  resetPassword(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getResetPasswordMutationOptions(options));
    }

export const getListFavoritesUrl = () => {




  return `/api/favorites`
}

/**
 * @summary List the current user's favorited model profiles
 */
export const listFavorites = async ( options?: RequestInit): Promise<Profile[]> => {

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


  }
);}





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


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListFavoritesQueryOptions(options)

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

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







export const getAddFavoriteUrl = () => {




  return `/api/favorites`
}

/**
 * @summary Add a model profile to favorites
 */
export const addFavorite = async (favoriteInput: FavoriteInput, options?: RequestInit): Promise<void> => {

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




export 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> => {

const mutationKey = ['addFavorite'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof addFavorite>>, {data: BodyType<FavoriteInput>}> = (props) => {
          const {data} = props ?? {};

          return  addFavorite(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAddFavoriteMutationOptions(options));
    }

export const getRemoveFavoriteUrl = (profileId: number,) => {




  return `/api/favorites/${profileId}`
}

/**
 * @summary Remove a model profile from favorites
 */
export const removeFavorite = async (profileId: number, options?: RequestInit): Promise<void> => {

  return customFetch<void>(getRemoveFavoriteUrl(profileId),
  {
    ...options,
    method: 'DELETE'


  }
);}




export 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> => {

const mutationKey = ['removeFavorite'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof removeFavorite>>, {profileId: number}> = (props) => {
          const {profileId} = props ?? {};

          return  removeFavorite(profileId,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type RemoveFavoriteMutationResult = NonNullable<Awaited<ReturnType<typeof removeFavorite>>>

    export type RemoveFavoriteMutationError = ErrorType<unknown>

    /**
 * @summary Remove a model profile from favorites
 */
export 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
      > => {
      return useMutation(getRemoveFavoriteMutationOptions(options));
    }

export const getGetMyProfileUrl = () => {




  return `/api/me/profile`
}

/**
 * @summary Get the current model's own profile
 */
export const getMyProfile = async ( options?: RequestInit): Promise<Profile> => {

  return customFetch<Profile>(getGetMyProfileUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetMyProfileQueryKey = () => {
    return [
    `/api/me/profile`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getGetMyProfileQueryOptions(options)

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

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







export const getUpdateMyProfileUrl = () => {




  return `/api/me/profile`
}

/**
 * @summary Update the current model's profile and pricing
 */
export const updateMyProfile = async (modelProfileUpdate: ModelProfileUpdate, options?: RequestInit): Promise<Profile> => {

  return customFetch<Profile>(getUpdateMyProfileUrl(),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      modelProfileUpdate,)
  }
);}




export 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> => {

const mutationKey = ['updateMyProfile'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof updateMyProfile>>, {data: BodyType<ModelProfileUpdate>}> = (props) => {
          const {data} = props ?? {};

          return  updateMyProfile(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getUpdateMyProfileMutationOptions(options));
    }

export const getGetMyEarningsUrl = () => {




  return `/api/me/earnings`
}

/**
 * @summary Get earnings estimated from completed bookings
 */
export const getMyEarnings = async ( options?: RequestInit): Promise<EarningsSummary> => {

  return customFetch<EarningsSummary>(getGetMyEarningsUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetMyEarningsQueryKey = () => {
    return [
    `/api/me/earnings`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getGetMyEarningsQueryOptions(options)

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

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







export const getListMyOrdersUrl = () => {




  return `/api/me/orders`
}

/**
 * @summary List incoming orders for the current model's profile
 */
export const listMyOrders = async ( options?: RequestInit): Promise<Booking[]> => {

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


  }
);}





export const getListMyOrdersQueryKey = () => {
    return [
    `/api/me/orders`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListMyOrdersQueryOptions(options)

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

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







export const getListMyPhotosUrl = () => {




  return `/api/me/photos`
}

/**
 * @summary List the current model's photo gallery
 */
export const listMyPhotos = async ( options?: RequestInit): Promise<ProfilePhoto[]> => {

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


  }
);}





export const getListMyPhotosQueryKey = () => {
    return [
    `/api/me/photos`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, ...queryOptions} as 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 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 } {

  const queryOptions = getListMyPhotosQueryOptions(options)

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

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







export const getAddMyPhotoUrl = () => {




  return `/api/me/photos`
}

/**
 * @summary Add a photo to the gallery
 */
export const addMyPhoto = async (addPhotoInput: AddPhotoInput, options?: RequestInit): Promise<ProfilePhoto> => {

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




export 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> => {

const mutationKey = ['addMyPhoto'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof addMyPhoto>>, {data: BodyType<AddPhotoInput>}> = (props) => {
          const {data} = props ?? {};

          return  addMyPhoto(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    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 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
      > => {
      return useMutation(getAddMyPhotoMutationOptions(options));
    }

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




  return `/api/me/photos/${id}`
}

/**
 * @summary Delete a photo from the gallery
 */
export const deleteMyPhoto = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




export 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> => {

const mutationKey = ['deleteMyPhoto'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof deleteMyPhoto>>, {id: number}> = (props) => {
          const {id} = props ?? {};

          return  deleteMyPhoto(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteMyPhotoMutationResult = NonNullable<Awaited<ReturnType<typeof deleteMyPhoto>>>

    export type DeleteMyPhotoMutationError = ErrorType<unknown>

    /**
 * @summary Delete a photo from the gallery
 */
export 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
      > => {
      return useMutation(getDeleteMyPhotoMutationOptions(options));
    }