type ObjectId = string

type Env = 'test' | 'development' | 'production' | 'preprod' | 'build' | 'ci'

type MaybeArray<T> = T | T[]
type MaybePromise<T> = T | Promise<T>

type HasKeys<T> = keyof T extends never ? false : true

type FunctionGeneric = (...params: any[]) => any
type ObjectGeneric = { [k: string]: any }

type ObjectWithNoFn = { [name: string]: NotFunction<any> }

// eslint-disable-next-line @typescript-eslint/ban-types
type NotFunction<T> = T extends Function ? never : T

type AsType<T, Type> = T extends Type ? T : Type

type AsString<T> = AsType<T, string>

type Complete<T> = {
  [P in keyof Required<T>]: T[P];
}

type CountryCodeIso = `${Letters}${Letters}`
type TranslationObj = { [countryIsoCode in CountryCodeIso]?: string }

type Override<T1, T2> = Omit<T1, keyof T2> & T2

type RecursivePartial<T> = {
  [P in keyof T]?: T[P] extends (infer U)[]
  ? RecursivePartial<U>[]
  : T[P] extends object
  ? RecursivePartial<T[P]>
  : T[P];
}

type Letters = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z'

type SimpleNumbers = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11

type ArrayOneOrMore<T> = { 0: T } & Array<T>

type RecursiveObjValueType<T, Type> = {
  [K in keyof T]?: T[K] extends object
  ? Type | RecursiveObjValueType<T[K], Type>
  : Type;
}

type TypeObjectValues<Obj extends Record<string, any>, Type> = {
  [K in keyof Obj]: Type;
}


/** Return true | false whenever an object has a property of type U */
type HasPropertyOfType<Objectt extends Record<string, any>, ExpectedType> = {
  [K in keyof Objectt]: Objectt[K] extends ExpectedType ? true : never;
}[keyof Objectt] extends never
  ? false
  : true

// https://stackoverflow.com/questions/49580725/is-it-possible-to-restrict-typescript-object-to-contain-only-properties-defined
type NoExtraProperties<T, U extends T = T> = U &
  MakeObjKeysAsNever<Exclude<keyof U, keyof T>>
type MakeObjKeysAsNever<K extends keyof any> = { [P in K]: never }

type RemoveTypeFromTuple<T, TypeToRemove> = T extends []
  ? []
  : T extends TypeToRemove
  ? []
  : T extends [infer A, ...infer R]
  ? [
    ...RemoveTypeFromTuple<A, TypeToRemove>,
    ...RemoveTypeFromTuple<R, TypeToRemove>
  ]
  : [T]

type GetTypeKeyFromObject<ObjType, Type> = {
  [P in keyof ObjType]: ObjType[P] extends Type ? never : P;
}[keyof ObjType]

/** Remove object key/values that are of a certain type */
type RemoveTypeFromObj<ObjType, Type> = Pick<
  ObjType,
  GetTypeKeyFromObject<ObjType, Type>
>


/** Get keys where the key type (number, string, Symbol...) is of Type */
type GetObjectKeysThatAreOfType<ObjType, Type> = {
  [P in keyof ObjType]: P extends Type ? P : never
}[keyof ObjType]

/** Remove Symbol and number from Object type */
type ForceStringKeyObject<Obj extends Record<any, any>> = Pick<
  Obj,
  GetObjectKeysThatAreOfType<Obj, string>
>


/** Get all indices of an array as a type. Eg: 0 | 1 | 2... */
type Indices<T extends readonly any[]> = Exclude<
  Partial<T>['length'],
  T['length']
>

/** Remove Readonly Modifier */
type Writeable<T> = { -readonly [P in keyof T]: T[P] }
/** Remove Readonly Modifier Recursively */
type DeepWriteable<T> = { -readonly [P in keyof T]: DeepWriteable<T[P]> }

/** used to type generic function without having to do (...params: any) => any */
type GenericFunction = (...params: any[]) => any
/** used like IsObject<ReturnType> extends true ? .... */
type IsObject<T> = T extends Record<string, any>
  ? T extends GenericFunction ? false
  : T extends any[] | readonly any[] ? false
  : true
  : false

type ReadonlyDeep<T> = {
  readonly [P in keyof T]: IsObject<T[P]> extends true
  ? ReadonlyDeep<T[P]>
  : T[P];
}

/** Equivalent of { myPropA: string, otherProp?: never } | { myPropA?: never, otherProp: string }. This would be written Exclusive<{ myPropA: string },  {  otherProp: string }> */
type Exclusive<
  A extends Record<string, any>,
  B extends Record<string, any>,
  C extends Record<string, any> = {},
  D extends Record<string, any> = {},
  E extends Record<string, any> = {}
> =
  | ({
    [P in Exclude<keyof A | keyof C | keyof D | keyof E, keyof B>]?: never;
  } & B)
  | ({
    [P in Exclude<keyof B | keyof C | keyof D | keyof E, keyof A>]?: never;
  } & A)
  | ({
    [P in Exclude<keyof B | keyof A | keyof D | keyof E, keyof C>]?: never;
  } & C)
  | ({
    [P in Exclude<keyof B | keyof A | keyof C | keyof E, keyof D>]?: never;
  } & D)
  | ({
    [P in Exclude<keyof B | keyof A | keyof C | keyof D, keyof E>]?: never;
  } & E)

type WeekDays = 0 | 1 | 2 | 3 | 4 | 5 | 6

type StringAndUnion<T> = T | (string & {})

type ArrayKeys<Arr extends any[] | readonly any[]> = keyof Arr & number




type PropsIntersection<T> = (T extends any ? (x: T) => void : never) extends (x: infer R) => void ? R : never

/** Giving a list of object, this will return a type similar to O1 & O2 & O3...
  * * It works well when with this structure ```type ObjOfObj = Record<string, Record<string>>```
  * * Giving that structure, if you want to extract ```ObjOfObj[keyof ObjOfObj]``` the type may
be never because its impossible to match O1 | O2...
 */
type MergeMultipleObjects<Obj extends Record<string, any>> = PropsIntersection<Obj[keyof Obj]>




/** Giving a list of required fields and subfields (dot notation) this type will return the object with the required fields added to type.
@example 
```ts
type Obj = {
  a: string;
  aOptional?: string;
  b: {
    c?: string
    d?: string
    e: string
  }
}

type RequiredFields = {
  aOptional: true
  'b.c': true
}

type Result = AddRequiredFieldsToObject<Obj, RequiredFields>

// PARSED TYPE:
type Obj = {
  a: string
  aOptional: string // this has became required because we specified it in RequiredFields
  b: {
    c: string // ALSO did this field
    d?: string // this one has kept being optional
    e: string //       " "        " "     required
  }
}
```
 */
type AddRequiredFieldsToObject<Obj extends Record<string, any>, RequiredFields extends Record<string, boolean>> = RemoveTypeFromObj<Required<{
  [K in keyof Obj]:
  K extends string
  // ? Obj[K] extends any[] | readonly any[] ? Obj[K] :
  ? K extends keyof RequiredFields
  ? (RequiredFields[K] extends true
    ? IsObject<Obj[K]> extends true
    ? AddRequiredFieldsToObject<Obj[K], {
      [P in keyof RequiredFields as P extends `${K}.${infer R}` ? R : never]: RequiredFields[P];
    }>
    : Obj[K]
    : never)
  : never
  : never
}>, never> &
  RemoveTypeFromObj<{
    [K in keyof Obj]:
    K extends string
    // ? Obj[K] extends any[] | readonly any[] ? Obj[K] :
    ? K extends keyof RequiredFields
    ? never
    : IsObject<Obj[K]> extends true
    ? AddRequiredFieldsToObject<Obj[K], {
      [P in keyof RequiredFields as P extends `${K}.${infer R}` ? R : never]: RequiredFields[P];
    }>
    : Obj[K]
    : never
  }, never>


/**
 * Removes the first element from a tuple type.
 *
 * @example
 * ```ts
 * type Example1 = RemoveFirst<[boolean, number, string]>; // [number, string]
 * type Example2 = RemoveFirst<[boolean, string]>; // [string]
 * type Example3 = RemoveFirst<[boolean]>; // []
 * type Example4 = RemoveFirst<[]>; // never
 * ```
 */
type RemoveFirstElementFromTuple<T extends any[]> = T extends [any, ...infer Rest] ? Rest : never;