export declare global {
  namespace Based {
    namespace i18n {
      type Languages =
        | 'en'
        | 'pt'
        | 'nl'
        | 'es'
        | 'de'
        | 'fr'
        | 'it'
        | 'fi'
        | 'ch'

      type Translations<T extends Record<string, any> = Record<string, any>> = {
        default: keyof T
        languages: T
      }

      type ValidKey = string | number

      type RemoveSuffix<S extends string> = S extends
        | `${infer Base}_none`
        | `${infer Base}_one`
        | `${infer Base}_many`
        ? Base
        : S

      type KeyVariants<K extends ValidKey> = K extends string
        ? K extends
            | `${infer Base}_none`
            | `${infer Base}_one`
            | `${infer Base}_many`
          ? K | Base
          : K
        : K

      type Decrement<N extends number> = N extends 0
        ? never
        : N extends infer _R
          ? [...Array<N>]['length']
          : never

      type IsPlainObject<T> = T extends object
        ? T extends any[]
          ? false
          : T extends Function
            ? false
            : true
        : false

      type NestedKeys<
        T,
        Prefix extends string = '',
        Depth extends number = 10,
      > = [Depth] extends [never]
        ? never
        : {
            [K in keyof T & ValidKey]: IsPlainObject<T[K]> extends true
              ?
                  | `${Prefix}${KeyVariants<K>}`
                  | NestedKeys<
                      T[K],
                      `${Prefix}${K & string}.`,
                      Decrement<Depth>
                    >
              : `${Prefix}${KeyVariants<K>}`
          }[keyof T & ValidKey]

      type Constructor<T extends Based.i18n.Translations> = (
        base: T,
      ) => <K extends T['languages'][T['default']]>(
        key: Based.i18n.NestedKeys<K>,
        ...params: any[]
      ) => any
    }
  }
}