export type Unformatted<T> = { [key in keyof T]?: T[key] | string | number | object }
export const OptionalProperty = <T>(value: T, condition?: (value: T) => boolean, fallback?: T): T => {
  if (value === null) return null
  if (condition) {
    const passes = condition(value)
    if (passes) {
      return value
    }
    return fallback || null
  }
  return value
}
export function emptyIfInvalid<T>(props: any, generator: { (prop?: any): T; isValid: (v: T) => boolean }): T {
  const processed = generator(props)
  if (generator.isValid(processed)) {
    return processed
  } else {
    return generator()
  }
}

// The main utility type function to merge interfaces
export type MergeUnion<T> = (T extends any ? (k: T) => void : never) extends (k: infer I) => void ? I : never

// The utility type to merge each property of a union into a new interface
export type MergeProps<T, K extends keyof T> = {
  [P in K]: T extends { [k in P]: infer U } ? U : never
}

// Combine the above two utility types to create the final merged interface
export type MergeInterfaces<T> = MergeProps<MergeUnion<T>, keyof MergeUnion<T>>