/**
 * Generated by orval v8.9.1 🍺
 * Do not edit manually.
 * 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 {
  Account,
  AccountInput,
  AccountStatement,
  AccountUpdate,
  DashboardSummary,
  Factory,
  FactoryInput,
  FactorySummaryItem,
  FactoryUpdate,
  GetAccountStatementParams,
  GetSupplierStatementParams,
  HealthStatus,
  ListPaymentsParams,
  ListSupplyOrdersParams,
  ListTransactionsParams,
  Payment,
  PaymentInput,
  Product,
  ProductInput,
  ProductUpdate,
  Supplier,
  SupplierInput,
  SupplierStatement,
  SupplierSummaryItem,
  SupplierUpdate,
  SupplyOrder,
  SupplyOrderInput,
  Transaction,
  TransactionInput,
  TransactionUpdate
} from './api.schemas';

import { customFetch } from '../custom-fetch';
import type { ErrorType , BodyType } from '../custom-fetch';

type AwaitedInput<T> = PromiseLike<T> | T;

      type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;


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



export const getHealthCheckUrl = () => {




  return `/api/healthz`
}

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

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


  }
);}





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


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

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

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



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





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

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


/**
 * @summary Health check
 */

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

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

  const queryOptions = getHealthCheckQueryOptions(options)

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

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







export const getListSuppliersUrl = () => {




  return `/api/suppliers`
}

/**
 * @summary قائمة الموردين
 */
export const listSuppliers = async ( options?: RequestInit): Promise<Supplier[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListSuppliersQueryResult = NonNullable<Awaited<ReturnType<typeof listSuppliers>>>
export type ListSuppliersQueryError = ErrorType<unknown>


/**
 * @summary قائمة الموردين
 */

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

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

  const queryOptions = getListSuppliersQueryOptions(options)

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

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







export const getCreateSupplierUrl = () => {




  return `/api/suppliers`
}

/**
 * @summary إضافة مورد
 */
export const createSupplier = async (supplierInput: SupplierInput, options?: RequestInit): Promise<Supplier> => {

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




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

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

          return  createSupplier(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateSupplierMutationResult = NonNullable<Awaited<ReturnType<typeof createSupplier>>>
    export type CreateSupplierMutationBody = BodyType<SupplierInput>
    export type CreateSupplierMutationError = ErrorType<unknown>

    /**
 * @summary إضافة مورد
 */
export const useCreateSupplier = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createSupplier>>, TError,{data: BodyType<SupplierInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createSupplier>>,
        TError,
        {data: BodyType<SupplierInput>},
        TContext
      > => {
      return useMutation(getCreateSupplierMutationOptions(options));
    }

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




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

/**
 * @summary تفاصيل مورد
 */
export const getSupplier = async (id: number, options?: RequestInit): Promise<Supplier> => {

  return customFetch<Supplier>(getGetSupplierUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





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

export type GetSupplierQueryResult = NonNullable<Awaited<ReturnType<typeof getSupplier>>>
export type GetSupplierQueryError = ErrorType<unknown>


/**
 * @summary تفاصيل مورد
 */

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

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

  const queryOptions = getGetSupplierQueryOptions(id,options)

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

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







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




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

/**
 * @summary تعديل مورد
 */
export const updateSupplier = async (id: number,
    supplierUpdate: SupplierUpdate, options?: RequestInit): Promise<Supplier> => {

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




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

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

          return  updateSupplier(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateSupplierMutationResult = NonNullable<Awaited<ReturnType<typeof updateSupplier>>>
    export type UpdateSupplierMutationBody = BodyType<SupplierUpdate>
    export type UpdateSupplierMutationError = ErrorType<unknown>

    /**
 * @summary تعديل مورد
 */
export const useUpdateSupplier = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateSupplier>>, TError,{id: number;data: BodyType<SupplierUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateSupplier>>,
        TError,
        {id: number;data: BodyType<SupplierUpdate>},
        TContext
      > => {
      return useMutation(getUpdateSupplierMutationOptions(options));
    }

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




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

/**
 * @summary حذف مورد
 */
export const deleteSupplier = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




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

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

          return  deleteSupplier(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteSupplierMutationResult = NonNullable<Awaited<ReturnType<typeof deleteSupplier>>>

    export type DeleteSupplierMutationError = ErrorType<unknown>

    /**
 * @summary حذف مورد
 */
export const useDeleteSupplier = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteSupplier>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteSupplier>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeleteSupplierMutationOptions(options));
    }

export const getGetSupplierStatementUrl = (params: GetSupplierStatementParams,) => {
  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/supplier-statement?${stringifiedParams}` : `/api/supplier-statement`
}

/**
 * @summary كشف حساب مورد
 */
export const getSupplierStatement = async (params: GetSupplierStatementParams, options?: RequestInit): Promise<SupplierStatement> => {

  return customFetch<SupplierStatement>(getGetSupplierStatementUrl(params),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetSupplierStatementQueryKey = (params?: GetSupplierStatementParams,) => {
    return [
    `/api/supplier-statement`, ...(params ? [params] : [])
    ] as const;
    }


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

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

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



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





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

export type GetSupplierStatementQueryResult = NonNullable<Awaited<ReturnType<typeof getSupplierStatement>>>
export type GetSupplierStatementQueryError = ErrorType<unknown>


/**
 * @summary كشف حساب مورد
 */

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

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

  const queryOptions = getGetSupplierStatementQueryOptions(params,options)

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

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







export const getListFactoriesUrl = () => {




  return `/api/factories`
}

/**
 * @summary قائمة المصانع
 */
export const listFactories = async ( options?: RequestInit): Promise<Factory[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListFactoriesQueryResult = NonNullable<Awaited<ReturnType<typeof listFactories>>>
export type ListFactoriesQueryError = ErrorType<unknown>


/**
 * @summary قائمة المصانع
 */

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

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

  const queryOptions = getListFactoriesQueryOptions(options)

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

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







export const getCreateFactoryUrl = () => {




  return `/api/factories`
}

/**
 * @summary إضافة مصنع
 */
export const createFactory = async (factoryInput: FactoryInput, options?: RequestInit): Promise<Factory> => {

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




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

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

          return  createFactory(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateFactoryMutationResult = NonNullable<Awaited<ReturnType<typeof createFactory>>>
    export type CreateFactoryMutationBody = BodyType<FactoryInput>
    export type CreateFactoryMutationError = ErrorType<unknown>

    /**
 * @summary إضافة مصنع
 */
export const useCreateFactory = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createFactory>>, TError,{data: BodyType<FactoryInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createFactory>>,
        TError,
        {data: BodyType<FactoryInput>},
        TContext
      > => {
      return useMutation(getCreateFactoryMutationOptions(options));
    }

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




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

/**
 * @summary تفاصيل مصنع
 */
export const getFactory = async (id: number, options?: RequestInit): Promise<Factory> => {

  return customFetch<Factory>(getGetFactoryUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





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

export type GetFactoryQueryResult = NonNullable<Awaited<ReturnType<typeof getFactory>>>
export type GetFactoryQueryError = ErrorType<unknown>


/**
 * @summary تفاصيل مصنع
 */

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

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

  const queryOptions = getGetFactoryQueryOptions(id,options)

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

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







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




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

/**
 * @summary تعديل مصنع
 */
export const updateFactory = async (id: number,
    factoryUpdate: FactoryUpdate, options?: RequestInit): Promise<Factory> => {

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




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

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

          return  updateFactory(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateFactoryMutationResult = NonNullable<Awaited<ReturnType<typeof updateFactory>>>
    export type UpdateFactoryMutationBody = BodyType<FactoryUpdate>
    export type UpdateFactoryMutationError = ErrorType<unknown>

    /**
 * @summary تعديل مصنع
 */
export const useUpdateFactory = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateFactory>>, TError,{id: number;data: BodyType<FactoryUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateFactory>>,
        TError,
        {id: number;data: BodyType<FactoryUpdate>},
        TContext
      > => {
      return useMutation(getUpdateFactoryMutationOptions(options));
    }

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




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

/**
 * @summary حذف مصنع
 */
export const deleteFactory = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




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

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

          return  deleteFactory(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteFactoryMutationResult = NonNullable<Awaited<ReturnType<typeof deleteFactory>>>

    export type DeleteFactoryMutationError = ErrorType<unknown>

    /**
 * @summary حذف مصنع
 */
export const useDeleteFactory = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteFactory>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteFactory>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeleteFactoryMutationOptions(options));
    }

export const getListProductsUrl = () => {




  return `/api/products`
}

/**
 * @summary قائمة الأصناف
 */
export const listProducts = async ( options?: RequestInit): Promise<Product[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListProductsQueryResult = NonNullable<Awaited<ReturnType<typeof listProducts>>>
export type ListProductsQueryError = ErrorType<unknown>


/**
 * @summary قائمة الأصناف
 */

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

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

  const queryOptions = getListProductsQueryOptions(options)

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

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







export const getCreateProductUrl = () => {




  return `/api/products`
}

/**
 * @summary إضافة صنف
 */
export const createProduct = async (productInput: ProductInput, options?: RequestInit): Promise<Product> => {

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




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

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

          return  createProduct(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateProductMutationResult = NonNullable<Awaited<ReturnType<typeof createProduct>>>
    export type CreateProductMutationBody = BodyType<ProductInput>
    export type CreateProductMutationError = ErrorType<unknown>

    /**
 * @summary إضافة صنف
 */
export const useCreateProduct = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createProduct>>, TError,{data: BodyType<ProductInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createProduct>>,
        TError,
        {data: BodyType<ProductInput>},
        TContext
      > => {
      return useMutation(getCreateProductMutationOptions(options));
    }

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




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

/**
 * @summary تعديل صنف
 */
export const updateProduct = async (id: number,
    productUpdate: ProductUpdate, options?: RequestInit): Promise<Product> => {

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




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

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

          return  updateProduct(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateProductMutationResult = NonNullable<Awaited<ReturnType<typeof updateProduct>>>
    export type UpdateProductMutationBody = BodyType<ProductUpdate>
    export type UpdateProductMutationError = ErrorType<unknown>

    /**
 * @summary تعديل صنف
 */
export const useUpdateProduct = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateProduct>>, TError,{id: number;data: BodyType<ProductUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateProduct>>,
        TError,
        {id: number;data: BodyType<ProductUpdate>},
        TContext
      > => {
      return useMutation(getUpdateProductMutationOptions(options));
    }

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




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

/**
 * @summary حذف صنف
 */
export const deleteProduct = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




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

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

          return  deleteProduct(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteProductMutationResult = NonNullable<Awaited<ReturnType<typeof deleteProduct>>>

    export type DeleteProductMutationError = ErrorType<unknown>

    /**
 * @summary حذف صنف
 */
export const useDeleteProduct = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteProduct>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteProduct>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeleteProductMutationOptions(options));
    }

export const getListSupplyOrdersUrl = (params?: ListSupplyOrdersParams,) => {
  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/supply-orders?${stringifiedParams}` : `/api/supply-orders`
}

/**
 * @summary قائمة أوامر التوريد
 */
export const listSupplyOrders = async (params?: ListSupplyOrdersParams, options?: RequestInit): Promise<SupplyOrder[]> => {

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


  }
);}





export const getListSupplyOrdersQueryKey = (params?: ListSupplyOrdersParams,) => {
    return [
    `/api/supply-orders`, ...(params ? [params] : [])
    ] as const;
    }


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

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

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



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





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

export type ListSupplyOrdersQueryResult = NonNullable<Awaited<ReturnType<typeof listSupplyOrders>>>
export type ListSupplyOrdersQueryError = ErrorType<unknown>


/**
 * @summary قائمة أوامر التوريد
 */

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

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

  const queryOptions = getListSupplyOrdersQueryOptions(params,options)

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

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







export const getCreateSupplyOrderUrl = () => {




  return `/api/supply-orders`
}

/**
 * @summary إضافة أمر توريد
 */
export const createSupplyOrder = async (supplyOrderInput: SupplyOrderInput, options?: RequestInit): Promise<SupplyOrder> => {

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




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

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

          return  createSupplyOrder(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateSupplyOrderMutationResult = NonNullable<Awaited<ReturnType<typeof createSupplyOrder>>>
    export type CreateSupplyOrderMutationBody = BodyType<SupplyOrderInput>
    export type CreateSupplyOrderMutationError = ErrorType<unknown>

    /**
 * @summary إضافة أمر توريد
 */
export const useCreateSupplyOrder = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createSupplyOrder>>, TError,{data: BodyType<SupplyOrderInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createSupplyOrder>>,
        TError,
        {data: BodyType<SupplyOrderInput>},
        TContext
      > => {
      return useMutation(getCreateSupplyOrderMutationOptions(options));
    }

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




  return `/api/supply-orders/${id}`
}

/**
 * @summary تفاصيل أمر توريد
 */
export const getSupplyOrder = async (id: number, options?: RequestInit): Promise<SupplyOrder> => {

  return customFetch<SupplyOrder>(getGetSupplyOrderUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetSupplyOrderQueryKey = (id: number,) => {
    return [
    `/api/supply-orders/${id}`
    ] as const;
    }


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

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

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



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





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

export type GetSupplyOrderQueryResult = NonNullable<Awaited<ReturnType<typeof getSupplyOrder>>>
export type GetSupplyOrderQueryError = ErrorType<unknown>


/**
 * @summary تفاصيل أمر توريد
 */

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

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

  const queryOptions = getGetSupplyOrderQueryOptions(id,options)

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

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







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




  return `/api/supply-orders/${id}`
}

/**
 * @summary حذف أمر توريد
 */
export const deleteSupplyOrder = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




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

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

          return  deleteSupplyOrder(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteSupplyOrderMutationResult = NonNullable<Awaited<ReturnType<typeof deleteSupplyOrder>>>

    export type DeleteSupplyOrderMutationError = ErrorType<unknown>

    /**
 * @summary حذف أمر توريد
 */
export const useDeleteSupplyOrder = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteSupplyOrder>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteSupplyOrder>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeleteSupplyOrderMutationOptions(options));
    }

export const getListAccountsUrl = () => {




  return `/api/accounts`
}

/**
 * @summary قائمة الحسابات
 */
export const listAccounts = async ( options?: RequestInit): Promise<Account[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListAccountsQueryResult = NonNullable<Awaited<ReturnType<typeof listAccounts>>>
export type ListAccountsQueryError = ErrorType<unknown>


/**
 * @summary قائمة الحسابات
 */

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

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

  const queryOptions = getListAccountsQueryOptions(options)

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

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







export const getCreateAccountUrl = () => {




  return `/api/accounts`
}

/**
 * @summary إضافة حساب
 */
export const createAccount = async (accountInput: AccountInput, options?: RequestInit): Promise<Account> => {

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




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

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

          return  createAccount(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateAccountMutationResult = NonNullable<Awaited<ReturnType<typeof createAccount>>>
    export type CreateAccountMutationBody = BodyType<AccountInput>
    export type CreateAccountMutationError = ErrorType<unknown>

    /**
 * @summary إضافة حساب
 */
export const useCreateAccount = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createAccount>>, TError,{data: BodyType<AccountInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createAccount>>,
        TError,
        {data: BodyType<AccountInput>},
        TContext
      > => {
      return useMutation(getCreateAccountMutationOptions(options));
    }

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




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

/**
 * @summary تفاصيل حساب
 */
export const getAccount = async (id: number, options?: RequestInit): Promise<Account> => {

  return customFetch<Account>(getGetAccountUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





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

export type GetAccountQueryResult = NonNullable<Awaited<ReturnType<typeof getAccount>>>
export type GetAccountQueryError = ErrorType<unknown>


/**
 * @summary تفاصيل حساب
 */

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

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

  const queryOptions = getGetAccountQueryOptions(id,options)

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

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







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




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

/**
 * @summary تعديل حساب
 */
export const updateAccount = async (id: number,
    accountUpdate: AccountUpdate, options?: RequestInit): Promise<Account> => {

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




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

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

          return  updateAccount(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateAccountMutationResult = NonNullable<Awaited<ReturnType<typeof updateAccount>>>
    export type UpdateAccountMutationBody = BodyType<AccountUpdate>
    export type UpdateAccountMutationError = ErrorType<unknown>

    /**
 * @summary تعديل حساب
 */
export const useUpdateAccount = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateAccount>>, TError,{id: number;data: BodyType<AccountUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateAccount>>,
        TError,
        {id: number;data: BodyType<AccountUpdate>},
        TContext
      > => {
      return useMutation(getUpdateAccountMutationOptions(options));
    }

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




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

/**
 * @summary حذف حساب
 */
export const deleteAccount = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




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

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

          return  deleteAccount(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteAccountMutationResult = NonNullable<Awaited<ReturnType<typeof deleteAccount>>>

    export type DeleteAccountMutationError = ErrorType<unknown>

    /**
 * @summary حذف حساب
 */
export const useDeleteAccount = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteAccount>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteAccount>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeleteAccountMutationOptions(options));
    }

export const getGetAccountStatementUrl = (params: GetAccountStatementParams,) => {
  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/account-statement?${stringifiedParams}` : `/api/account-statement`
}

/**
 * @summary كشف حساب
 */
export const getAccountStatement = async (params: GetAccountStatementParams, options?: RequestInit): Promise<AccountStatement> => {

  return customFetch<AccountStatement>(getGetAccountStatementUrl(params),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetAccountStatementQueryKey = (params?: GetAccountStatementParams,) => {
    return [
    `/api/account-statement`, ...(params ? [params] : [])
    ] as const;
    }


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

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

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



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





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

export type GetAccountStatementQueryResult = NonNullable<Awaited<ReturnType<typeof getAccountStatement>>>
export type GetAccountStatementQueryError = ErrorType<unknown>


/**
 * @summary كشف حساب
 */

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

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

  const queryOptions = getGetAccountStatementQueryOptions(params,options)

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

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







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

/**
 * @summary قائمة المعاملات المالية
 */
export const listTransactions = async (params?: ListTransactionsParams, options?: RequestInit): Promise<Transaction[]> => {

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


  }
);}





export const getListTransactionsQueryKey = (params?: ListTransactionsParams,) => {
    return [
    `/api/transactions`, ...(params ? [params] : [])
    ] as const;
    }


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

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

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



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





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

export type ListTransactionsQueryResult = NonNullable<Awaited<ReturnType<typeof listTransactions>>>
export type ListTransactionsQueryError = ErrorType<unknown>


/**
 * @summary قائمة المعاملات المالية
 */

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

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

  const queryOptions = getListTransactionsQueryOptions(params,options)

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

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







export const getCreateTransactionUrl = () => {




  return `/api/transactions`
}

/**
 * @summary إضافة معاملة مالية
 */
export const createTransaction = async (transactionInput: TransactionInput, options?: RequestInit): Promise<Transaction> => {

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




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

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

          return  createTransaction(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateTransactionMutationResult = NonNullable<Awaited<ReturnType<typeof createTransaction>>>
    export type CreateTransactionMutationBody = BodyType<TransactionInput>
    export type CreateTransactionMutationError = ErrorType<unknown>

    /**
 * @summary إضافة معاملة مالية
 */
export const useCreateTransaction = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createTransaction>>, TError,{data: BodyType<TransactionInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createTransaction>>,
        TError,
        {data: BodyType<TransactionInput>},
        TContext
      > => {
      return useMutation(getCreateTransactionMutationOptions(options));
    }

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




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

/**
 * @summary تفاصيل معاملة
 */
export const getTransaction = async (id: number, options?: RequestInit): Promise<Transaction> => {

  return customFetch<Transaction>(getGetTransactionUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





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

export type GetTransactionQueryResult = NonNullable<Awaited<ReturnType<typeof getTransaction>>>
export type GetTransactionQueryError = ErrorType<unknown>


/**
 * @summary تفاصيل معاملة
 */

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

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

  const queryOptions = getGetTransactionQueryOptions(id,options)

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

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







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




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

/**
 * @summary تعديل معاملة
 */
export const updateTransaction = async (id: number,
    transactionUpdate: TransactionUpdate, options?: RequestInit): Promise<Transaction> => {

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




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

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

          return  updateTransaction(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateTransactionMutationResult = NonNullable<Awaited<ReturnType<typeof updateTransaction>>>
    export type UpdateTransactionMutationBody = BodyType<TransactionUpdate>
    export type UpdateTransactionMutationError = ErrorType<unknown>

    /**
 * @summary تعديل معاملة
 */
export const useUpdateTransaction = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateTransaction>>, TError,{id: number;data: BodyType<TransactionUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateTransaction>>,
        TError,
        {id: number;data: BodyType<TransactionUpdate>},
        TContext
      > => {
      return useMutation(getUpdateTransactionMutationOptions(options));
    }

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




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

/**
 * @summary حذف معاملة
 */
export const deleteTransaction = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




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

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

          return  deleteTransaction(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteTransactionMutationResult = NonNullable<Awaited<ReturnType<typeof deleteTransaction>>>

    export type DeleteTransactionMutationError = ErrorType<unknown>

    /**
 * @summary حذف معاملة
 */
export const useDeleteTransaction = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteTransaction>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteTransaction>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeleteTransactionMutationOptions(options));
    }

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

/**
 * @summary قائمة الدفعات
 */
export const listPayments = async (params?: ListPaymentsParams, options?: RequestInit): Promise<Payment[]> => {

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


  }
);}





export const getListPaymentsQueryKey = (params?: ListPaymentsParams,) => {
    return [
    `/api/payments`, ...(params ? [params] : [])
    ] as const;
    }


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

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

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



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





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

export type ListPaymentsQueryResult = NonNullable<Awaited<ReturnType<typeof listPayments>>>
export type ListPaymentsQueryError = ErrorType<unknown>


/**
 * @summary قائمة الدفعات
 */

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

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

  const queryOptions = getListPaymentsQueryOptions(params,options)

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

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







export const getCreatePaymentUrl = () => {




  return `/api/payments`
}

/**
 * @summary إضافة دفعة
 */
export const createPayment = async (paymentInput: PaymentInput, options?: RequestInit): Promise<Payment> => {

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




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

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

          return  createPayment(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreatePaymentMutationResult = NonNullable<Awaited<ReturnType<typeof createPayment>>>
    export type CreatePaymentMutationBody = BodyType<PaymentInput>
    export type CreatePaymentMutationError = ErrorType<unknown>

    /**
 * @summary إضافة دفعة
 */
export const useCreatePayment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createPayment>>, TError,{data: BodyType<PaymentInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createPayment>>,
        TError,
        {data: BodyType<PaymentInput>},
        TContext
      > => {
      return useMutation(getCreatePaymentMutationOptions(options));
    }

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




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

/**
 * @summary حذف دفعة
 */
export const deletePayment = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




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

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

          return  deletePayment(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeletePaymentMutationResult = NonNullable<Awaited<ReturnType<typeof deletePayment>>>

    export type DeletePaymentMutationError = ErrorType<unknown>

    /**
 * @summary حذف دفعة
 */
export const useDeletePayment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deletePayment>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deletePayment>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeletePaymentMutationOptions(options));
    }

export const getGetDashboardSummaryUrl = () => {




  return `/api/reports/dashboard`
}

/**
 * @summary ملخص لوحة التحكم
 */
export const getDashboardSummary = async ( options?: RequestInit): Promise<DashboardSummary> => {

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


  }
);}





export const getGetDashboardSummaryQueryKey = () => {
    return [
    `/api/reports/dashboard`
    ] 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 ملخص لوحة التحكم
 */

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 getGetSupplierSummaryUrl = () => {




  return `/api/reports/supplier-summary`
}

/**
 * @summary ملخص الموردين
 */
export const getSupplierSummary = async ( options?: RequestInit): Promise<SupplierSummaryItem[]> => {

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


  }
);}





export const getGetSupplierSummaryQueryKey = () => {
    return [
    `/api/reports/supplier-summary`
    ] as const;
    }


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

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

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



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





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

export type GetSupplierSummaryQueryResult = NonNullable<Awaited<ReturnType<typeof getSupplierSummary>>>
export type GetSupplierSummaryQueryError = ErrorType<unknown>


/**
 * @summary ملخص الموردين
 */

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

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

  const queryOptions = getGetSupplierSummaryQueryOptions(options)

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

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







export const getGetFactorySummaryUrl = () => {




  return `/api/reports/factory-summary`
}

/**
 * @summary ملخص المصانع
 */
export const getFactorySummary = async ( options?: RequestInit): Promise<FactorySummaryItem[]> => {

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


  }
);}





export const getGetFactorySummaryQueryKey = () => {
    return [
    `/api/reports/factory-summary`
    ] as const;
    }


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

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

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



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





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

export type GetFactorySummaryQueryResult = NonNullable<Awaited<ReturnType<typeof getFactorySummary>>>
export type GetFactorySummaryQueryError = ErrorType<unknown>


/**
 * @summary ملخص المصانع
 */

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

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

  const queryOptions = getGetFactorySummaryQueryOptions(options)

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

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